utils_backup.py

#  Copyright (C) 2026  EmGi

# You are free to modify it under the terms of the GNU General Public License as published by the Free Software Foundation.
# You are free to use any models Generated by this Addon Commercially

import bpy # type: ignore
import webbrowser
from collections import deque
import xml.etree.ElementTree as ET
import math
import requests # type: ignore
import time
from datetime import date
from datetime import datetime
import bmesh # type: ignore
from mathutils import Vector, bvhtree, Euler
import os
import sys
import json
import platform
import zlib
import struct
import csv
import random
import hashlib
import zipfile
import io
import addon_utils
from .export import export_to_STL, export_selected_to_STL, export_selected_to_3mf, customThumbnail, get_selection_center, is_3mf_extension_installed, install_3mf_extension

from bpy.app.translations import pgettext as _

from . import progress as _progress
from . import addon_preferences


from . import bl_info
from . import panels
from . import constants as const




def open_website(self, context, url="https://patreon.com/EmGi3D?utm_source=Blender"):
    print(url)
    webbrowser.open(url)


def save_myproperties_to_csv(filename):
    """
    Save all writable properties of a MyProperties instance to a CSV file.
    Each row is: property_name , value
    """
    folder = const.preset_dir
    os.makedirs(folder, exist_ok=True)

    filepath = os.path.join(folder, filename + ".csv")

    props = bpy.context.scene.tp3d

    print(filepath)

    with open(filepath, "w", newline="", encoding="utf-8") as f:
        writer = csv.writer(f)
        writer.writerow(["property", "value"])  # header

        for p in props.bl_rna.properties:
            name = p.identifier
            if name == "rna_type" or p.is_readonly:
                continue

            try:
                value = getattr(props, name)
            except:
                continue

            # Convert lists/tuples to string
            if isinstance(value, (list, tuple)):
                value = ",".join(map(str, value))

            writer.writerow([name, value])

def appendCollection():

    addon_dir = os.path.dirname(__file__)
    filepath = os.path.join(addon_dir, "assets", bpy.context.scene.tp3d.specialBlendFile)
    collection_name = bpy.context.scene.tp3d.specialCollectionName

    #If the collection already exists, delete it and its contents
    collection = bpy.data.collections.get(collection_name)
    if collection:
        bpy.context.scene.collection.children.unlink(collection)
        bpy.data.collections.remove(collection)

    print(f"Collection to Import: {collection_name}")
    with bpy.data.libraries.load(filepath, link=False) as (data_from, data_to):
        if collection_name in data_from.collections:
            data_to.collections.append(collection_name)
        else:
            print(f"Collection '{collection_name}' not found.")
            return

    col = bpy.data.collections.get(collection_name)
    if col:
        bpy.context.scene.collection.children.link(col)

        scene_col = bpy.context.scene.collection
        objs = list(col.objects)
        roots = [o for o in objs if not o.parent]
        if roots:
            roots[0].location = bpy.context.scene.cursor.location

        return_obj = None
        for obj in objs:
            scene_col.objects.link(obj)
            col.objects.unlink(obj)

            #eg jigzaw or slider puzzles
            if "BLANK" in obj.name or "Blank" in obj.name:
                bpy.ops.object.select_all(action='DESELECT')
                obj.select_set(True)
                bpy.context.view_layer.objects.active = obj

                parts = collection_name.split("_")
                for part in parts[1:]:          # everything after a "_"
                    num = part.split("mm")[0]   # take what's before "mm"
                    if "mm" in part and num.replace(".", "", 1).isdigit():
                        bpy.context.scene.tp3d.objSize = int(num)
                        break

                return_obj = obj
            if "objSize" in obj.keys():
                scaleFactor = 1/100 * bpy.context.scene.tp3d.objSize
                obj.scale = (scaleFactor, scaleFactor, scaleFactor)

        scene_col.children.unlink(col)
        bpy.data.collections.remove(col)

        return return_obj

    else:
        return None
        
def get_external_collections(path):
    if not os.path.exists(path):
        return []
    with bpy.data.libraries.load(path, link=True) as (data_from, _):
        return list(data_from.collections)

def loadCollections(self, context):


    addon_dir = os.path.dirname(__file__)
    path = os.path.join(addon_dir, "assets", bpy.context.scene.tp3d.specialBlendFile)
    names = get_external_collections(path)

    const.specialCollection = [(name, name, "") for name in names]

    first_name = names[0]
    if first_name in [item.identifier for item in bpy.context.scene.tp3d.bl_rna.properties["specialCollectionName"].enum_items]:
        bpy.context.scene.tp3d.specialCollectionName = first_name

    bpy.context.scene.tp3d.specialCollectionName = first_name

    print(f"First name: {first_name}")

def load_myproperties_from_csv(filename):
    """
    Load all properties from a CSV file and overwrite the values in MyProperties.
    """
    folder = const.preset_dir
    filepath = os.path.join(folder, filename + ".csv")

    if not os.path.isfile(filepath):
        print("Preset file not found:", filepath)
        return

    props = bpy.context.scene.tp3d

    with open(filepath, "r", encoding="utf-8") as f:
        reader = csv.reader(f)
        next(reader)  # skip header

        for row in reader:
            if len(row) < 2:
                continue

            name, value = row[0], row[1]

            if not hasattr(props, name):
                continue  # skip unknown properties

            current = getattr(props, name)

            try:
                # Convert back to correct type
                if isinstance(current, bool):
                    value = value.lower() == "true"

                elif isinstance(current, int):
                    value = int(value)

                elif isinstance(current, float):
                    value = float(value)

                elif isinstance(current, (list, tuple)):
                    # Split list stored as comma-separated string
                    value = [float(v) for v in value.split(",")]

                # strings stay strings
            except:
                # Failed conversion → keep original
                continue

            try:
                setattr(props, name, value)
            except:
                pass

def delete_preset_file(preset_name):
    """
    Deletes a preset .csv file from the Blender CONFIG/presets folder.
    preset_name = name WITHOUT extension
    """
    folder = const.preset_dir
    filepath = os.path.join(folder, preset_name + ".csv")

    if not os.path.isfile(filepath):
        print("File not found:", filepath)
        return False

    try:
        os.remove(filepath)
        print("Deleted:", filepath)
        return True
    except Exception as e:
        print("Error deleting file:", e)
        return False

        
def list_files_callback(self, context):
    folder = const.preset_dir
    items = []

    if os.path.isdir(folder):
        for fname in os.listdir(folder):
            if os.path.isfile(os.path.join(folder, fname)):
                name_no_ext = os.path.splitext(fname)[0]
                items.append((name_no_ext, name_no_ext, ""))

    # Show placeholder if empty
    if not items:
        items.append(("none", "-- No files found --", ""))

    return items


def load_counter():
    if os.path.exists(const.counter_file):
        try:
            with open(const.counter_file, "r") as f:
                data = json.load(f)
                return data.get("count_openTopodata", 0), data.get("date_openTopoData", ""), data.get("count_openElevation",0), data.get("date_openElevation","")
        except:
            return 0, "", 0, ""
    return 0, "", 0, ""

# Function to save the counter data
def save_counter(count_openTopodata, date_openTopoData, count_openElevation, date_openElevation):
    with open(const.counter_file, "w") as f:
        json.dump({"count_openTopodata": count_openTopodata, "date_openTopoData": date_openTopoData, "count_openElevation": count_openElevation, "date_openElevation": date_openElevation}, f)

# Function to update the request counter
def update_request_counter():

    api = bpy.context.scene.tp3d.api

    today = date.today().isoformat()  # ✅ This correctly gets today's date
    today_date = date.today().isoformat()  # Get today's date in iso format
    today_month = date.today().month  # Get current month as an integer (1-12)
    count_openTopodata, date_openTopoData, count_openElevation, date_openElevation = load_counter()

    # Reset counter if the date has changed
    if date_openTopoData != today_date:
        count_openTopodata = 0
    
    if date_openElevation != today_month:
        count_openElevation = 0

    if api == "OPENTOPODATA":
        count_openTopodata += 1
    elif api == "OPEN-ELEVATION":
        count_openElevation += 1

    save_counter(count_openTopodata, today_date, count_openElevation,today_month)
    
    return count_openTopodata, count_openElevation  # Return the updated count

def send_api_request(addition = ""):
    
    dataset = bpy.context.scene.tp3d.dataset
    api = bpy.context.scene.tp3d.api

    request_count = update_request_counter()
    now = datetime.now()
    if api == "OPENTOPODATA":
        print(f"{now.hour:02d}:{now.minute:02d} | Fetching: {addition} | API Usage: {request_count} | {dataset}")
    elif api == "OPEN-ELEVATION":
        print(f"{now.hour:02d}:{now.minute:02d} | Fetching: {addition} | API Usage: {request_count}")
    elif api == "TERRAIN-TILES":
        print(f"{now.hour:02d}:{now.minute:02d} | Fetching API")
    

#--------------------------------------------------------------------------------------------------------------------
#DISPLAY GENERATION----------------------------------------------------------------------------------------------------------
#--------------------------------------------------------------------------------------------------------------------
def _parse_points(points, point_type):
    segcoords = []
    lowestElevation = float("inf")

    for pt in points:
        lat = float(pt.get("lat"))
        lon = float(pt.get("lon"))

        ele = None
        time = None

        for c in pt:
            tag = c.tag.split("}")[-1]
            if tag == "ele":
                ele = c
            elif tag == "time":
                time = c

        elevation = float(ele.text) if ele is not None else 0.0

        try:
            timestamp = (
                datetime.fromisoformat(time.text.replace("Z", "+00:00"))
                if time is not None else None
            )
        except Exception:
            timestamp = None

        segcoords.append((lat, lon, elevation, timestamp))
        lowestElevation = min(lowestElevation, elevation)

    bpy.context.scene.tp3d["o_verticesPath"] = f"{point_type} Path vertices: {len(segcoords)}"

    return segcoords

def read_gpx(filepath):
    """
    Universal GPX reader.
    Supports:
    - GPX 1.1 / 1.0
    - trk / trkseg / trkpt
    - rte / rtept
    - files without namespaces
    """

    tree = ET.parse(filepath)
    root = tree.getroot()

    segmentlist = []

    # --------------------------------------------------
    # Namespace handling (GPX 1.1 / 1.0 / none)
    # --------------------------------------------------
    def strip_ns(tag):
        return tag.split("}")[-1]

    def findall_any(elem, names):
        return [e for e in elem.iter() if strip_ns(e.tag) in names]

    def find_child(elem, names):
        for c in elem:
            if strip_ns(c.tag) in names:
                return c
        return None

    # --------------------------------------------------
    # Track segments
    # --------------------------------------------------
    trksegs = findall_any(root, ["trkseg"])

    if trksegs:
        for seg in trksegs:
            points = [p for p in seg if strip_ns(p.tag) == "trkpt"]
            if points:
                segmentlist.append(
                    _parse_points(points, "TRKPT")
                )

    # --------------------------------------------------
    # Routes (fallback or additional if no segments found)
    # --------------------------------------------------
    routes = findall_any(root, ["rte"])
    for rte in routes:
        points = [p for p in rte if strip_ns(p.tag) == "rtept"]
        if points:
            segmentlist.append(
                _parse_points(points, "RTEPT")
            )

    # --------------------------------------------------
    # Edge case: GPX with direct trkpt/rtept (rare but real)
    # --------------------------------------------------
    if not segmentlist:
        points = findall_any(root, ["trkpt", "rtept"])
        if points:
            segmentlist.append(
                _parse_points(points, "POINT")
            )

    return segmentlist

def read_igc(filepath):
    """Reads an IGC file and extracts the coordinates, elevation, and timestamps."""
    segmentlist = []
    coordinates = []
    lowestElevation = 10000
    
    with open(filepath, 'r') as file:
        for line in file:
            # IGC B records contain position data
            if line.startswith('B'):
                try:
                    # Extract time (HHMMSS)
                    time_str = line[1:7]
                    hours = int(time_str[0:2])
                    minutes = int(time_str[2:4])
                    seconds = int(time_str[4:6])
                    
                    # Extract latitude (DDMMmmmN/S)
                    lat_str = line[7:15]
                    lat_deg = int(lat_str[0:2])
                    lat_min = int(lat_str[2:4])
                    lat_min_frac = int(lat_str[4:7]) / 1000.0
                    lat = lat_deg + (lat_min + lat_min_frac) / 60.0
                    if lat_str[7] == 'S':
                        lat = -lat
                    
                    # Extract longitude (DDDMMmmmE/W)
                    lon_str = line[15:24]
                    lon_deg = int(lon_str[0:3])
                    lon_min = int(lon_str[3:5])
                    lon_min_frac = int(lon_str[5:8]) / 1000.0
                    lon = lon_deg + (lon_min + lon_min_frac) / 60.0
                    if lon_str[8] == 'W':
                        lon = -lon
                    
                    # Extract pressure altitude (in meters)
                    pressure_alt = int(line[25:30])
                    
                    # Extract GPS altitude (in meters)
                    gps_alt = int(line[30:35])
                    
                    # Create timestamp (using current date since IGC files don't store date in B records)
                    now = datetime.now()
                    timestamp = datetime(now.year, now.month, now.day, hours, minutes, seconds)
                    
                    # Use GPS altitude for elevation
                    elevation = gps_alt
                    
                    coordinates.append((lat, lon, elevation, timestamp))
                    
                    if elevation < lowestElevation:
                        lowestElevation = elevation
                        
                except (ValueError, IndexError) as e:
                    print(f"Error parsing IGC line: {line.strip()}")
                    continue
    
    bpy.context.scene.tp3d["o_verticesPath"] = "Path vertices: " + str(len(coordinates))

    segmentlist.append(coordinates)
    return segmentlist


def read_gpx_directory(directory_path):
    """Reads all GPX files in a directory and extracts coordinates, elevation, and timestamps."""
    
    # Define GPX namespace
    ns = {'default': 'http://www.topografix.com/GPX/1/1'}
    
    # List to store all coordinates from all GPX files, grouped by file.
    # Structure: [[seg1, seg2, ...], [seg1, ...], ...] — one inner list per file,
    # each inner list contains that file's track segments.
    coordinatesByFile = []
    lowestElevation = 10000  # High initial value

    # Iterate over all files in the directory
    for filename in os.listdir(directory_path):
        if filename.lower().endswith(".gpx") or filename.lower().endswith(".igc"):
            filepath = os.path.join(directory_path, filename)

            file_extension = os.path.splitext(filepath)[1].lower()
            if file_extension == '.gpx':
                tree = ET.parse(filepath)
                root = tree.getroot()
                version = root.get("version")
                print(f"File Name: {filename}, File Version: {version}")
                co = read_gpx(filepath)
            elif file_extension == '.igc':
                co = read_igc(filepath)

            # Keep all segments from this file together as a group
            if co:
                coordinatesByFile.append(co)
                for coseg in co:
                    lowest = min(coseg, key=lambda x: x[2])
                    lowest_In_coords = lowest[2]
                    if lowest_In_coords < lowestElevation:
                        lowestElevation = lowest_In_coords
                        print(f"new Lowest Elevation: {lowestElevation}")

    # Flatten for vertex count reporting
    coordinatesSeparate = [seg for file_segs in coordinatesByFile for seg in file_segs]
    coordinates = [pt for seg in coordinatesSeparate for pt in seg]

    # Store the number of points in the Blender scene property
    bpy.context.scene.tp3d["o_verticesPath"] = f"Path vertices: {len(coordinates)}"

    print(f"Total GPX files processed: {len(coordinatesByFile)}")

    return coordinatesByFile

def read_gpx_file():

    gpx_file_path = bpy.context.scene.tp3d.get('file_path', None)

    coords = []
    file_extension = os.path.splitext(gpx_file_path)[1].lower()
    if file_extension == '.gpx':
        tree = ET.parse(gpx_file_path)
        root = tree.getroot()
        version = root.get("version")

        ns = {'default': root.tag.split('}')[0].strip('{')}
        GPXsections = len(root.findall(".//default:trkseg", ns))
        print(f"GPX Sections found in GPX File: {GPXsections}")
        coords = read_gpx(gpx_file_path)
    elif file_extension == '.igc':
        coords= read_igc(gpx_file_path)
    else:
        show_message_box("Unsupported file format. Please use .gpx or .igc files.")
        return

    
    return coords
    

# Load cache from disk
def load_elevation_cache():
    """Load the elevation cache from disk"""

    if os.path.exists(const.elevation_cache_file):
        try:
            with open(const.elevation_cache_file, "r") as f:
                const._elevation_cache = json.load(f)
        except Exception as e:
            print(f"Error loading elevation cache: {str(e)}")
            const._elevation_cache = {}
    else:
        const._elevation_cache = {}

# Save cache to disk
def save_elevation_cache():
    """Save the elevation cache from Opentopodata or OpenElevation to disk"""

    cacheSize = bpy.context.scene.tp3d.ccacheSize

    # Limit cache size to prevent excessive file sizes
    #print(f"Currently cached:  {len(_elevation_cache)}")
    if len(const._elevation_cache) > cacheSize:
        # Keep only the most recent entries
        keys = list(const._elevation_cache.keys())
        for key in keys[:-cacheSize]:
            del const._elevation_cache[key]
            
    try:
        with open(const.elevation_cache_file, "w") as f:
            json.dump(const._elevation_cache, f)
    except Exception as e:
        print(f"Error saving elevation cache: {str(e)}")

def get_cached_elevation(lat, lon, api_type="opentopodata"):
    """Get elevation from cache if available"""
    key = f"{lat:.5f}_{lon:.5f}_{api_type}"
    return const._elevation_cache.get(key)

def cache_elevation(lat, lon, elevation, api_type="opentopodata"):
    """Cache elevation data"""
    key = f"{lat:.5f}_{lon:.5f}_{api_type}"
    const._elevation_cache[key] = elevation

def _setup_material(name, color):
    if name not in bpy.data.materials:
        mat = bpy.data.materials.new(name=name)
    else:
        mat = bpy.data.materials[name]

    mat.use_nodes = True
    nodes = mat.node_tree.nodes
    links = mat.node_tree.links

    bsdf = next((n for n in nodes if n.type == 'BSDF_PRINCIPLED'), None)
    if not bsdf:
        bsdf = nodes.new(type="ShaderNodeBsdfPrincipled")
        bsdf.location = (0, 0)

    output = next((n for n in nodes if n.type == 'OUTPUT_MATERIAL'), None)
    if not output:
        output = nodes.new(type="ShaderNodeOutputMaterial")
        output.location = (300, 0)

    if not bsdf.outputs["BSDF"].is_linked:
        links.new(bsdf.outputs["BSDF"], output.inputs["Surface"])

    bsdf.inputs["Base Color"].default_value = color

def setupColors():
    _setup_material("BASE",      (0.05, 0.7,  0.05, 1.0))
    _setup_material("FOREST",    (0.05, 0.25, 0.05, 1.0))
    _setup_material("MOUNTAIN",  (0.5,  0.5,  0.5,  1.0))
    _setup_material("WATER",     (0.0,  0.0,  0.8,  1.0))
    _setup_material("TRAIL",     (1.0,  0.0,  0.0,  1.0))
    _setup_material("YELLOW",    (1.0,  1.0,  0.0,  1.0))
    _setup_material("CITY",      (0.7,  0.7,  0.1,  1.0))
    _setup_material("GLACIER",   (0.8,  0.9,  0.8,  1.0))
    _setup_material("BLACK",     (0.0,  0.0,  0.0,  1.0))
    _setup_material("WHITE",     (1.0,  1.0,  1.0,  1.0))
    _setup_material("BUILDINGS", (0.4,  0.4,  0.4,  1.0))
    _setup_material("FARMLAND",  (0.3,  0.5,  0.1,  1.0))

def calculate_scale(mapSize, coordinates, gen_type):
    
    scalemode = bpy.context.scene.tp3d.scalemode
    pathScale = bpy.context.scene.tp3d.pathScale
    
    #for lat, lon, ele in coordinates:
    min_lat = min(point[0] for point in coordinates)
    max_lat = max(point[0] for point in coordinates)
    min_lon = min(point[1] for point in coordinates)
    max_lon = max(point[1] for point in coordinates)

    
    R = const.R
    #x1 = R * math.radians(min_lon)
    #x1 = R * math.radians(min_lon) * math.cos(math.radians(min_lat))
    #y1 = R * math.log(math.tan(math.pi / 4 + math.radians(min_lat) / 2))
    #x2 = R * math.radians(max_lon)
    #x2 = R * math.radians(max_lon) * math.cos(math.radians(max_lat))
    #y2 = R * math.log(math.tan(math.pi / 4 + math.radians(max_lat) / 2))
    #width = abs(x2 - x1)
    #height = abs(y2 - y1)
    #distance = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)

    x1, y1, e = convert_to_neutral_coordinates(min_lat, min_lon, 0,0)
    x2, y2, e = convert_to_neutral_coordinates(max_lat, max_lon, 0,0)

    if scalemode == "FACTOR" and gen_type != 2:
        width = abs(x2 - x1)
        height = abs(y2 - y1)
        distance = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)

    else:
        width = haversine(min_lat, min_lon, min_lat, max_lon) * 1
        height = haversine(min_lat, min_lon, max_lat,min_lon) * 1
        distance = haversine(min_lat,min_lon,max_lat,max_lon)*1


    #COMMENTED OUT
    #CALCULATES THE ACCURATE SCALE BUT MULTIPLE PATHS TO EACH OTHER WONT ALIGN CORRECTLY WITH IT AS THE "mf"
    #IS DIFFRENT FOR EACH LATITUDE AND THEREFORE HAS A DIFFRENT "COORDINATE SYSTEM"
    if scalemode == "SCALE":
        mx1 = x1 = R * math.radians(min_lon) * math.cos(math.radians(min_lat))
        mx2 = x2 = R * math.radians(max_lon) * math.cos(math.radians(max_lat))
        mwidth = abs(mx1 - mx2)
        mf = 1/width * mwidth
        mf = 1

    if scalemode == "COORDINATES" or scalemode == "SCALE":
        distance = 0


    maxer = max(width,height, distance)

    scale = 1
    if scalemode == "COORDINATES" or gen_type == 2 or gen_type == 3:
        #print("scalemode1")
        scale = mapSize / maxer
    elif scalemode == "FACTOR":
        scale = (mapSize * pathScale) / maxer
    elif scalemode == "SCALE":
        scale = pathScale * mf

    return scale

def convert_to_blender_coordinates(lat, lon, elevation,timestamp):

    scaleHor = bpy.context.scene.tp3d.sScaleHor
    autoScale = bpy.context.scene.tp3d.sAutoScale
    scaleElevation = bpy.context.scene.tp3d.scaleElevation

    R = const.R
    x = R * math.radians(lon) * scaleHor
    y = R * math.log(math.tan(math.pi / 4 + math.radians(lat) / 2)) * scaleHor
    z = elevation / 1000 * scaleElevation * autoScale

    
    return (x, y, z)

def convert_to_neutral_coordinates(lat, lon, elevation,timestamp):

    autoScale = bpy.context.scene.tp3d.sAutoScale
    scaleElevation = bpy.context.scene.tp3d.scaleElevation

    R = const.R
    x = R * math.radians(lon)
    y = R * math.log(math.tan(math.pi / 4 + math.radians(lat) / 2))
    z = elevation / 1000 * scaleElevation * autoScale
    
    
    
    
    return (x, y, z)


# Convert offsets to latitude/longitude
def convert_to_geo(x,y):
    """Converts Blender x/y offsets to latitude/longitude."""

    scaleHor = bpy.context.scene.tp3d.sScaleHor
    
    R = const.R
    longitude = math.degrees((x) / (R * scaleHor) )
    latitude = math.degrees(2 * math.atan(math.exp((y) / (R * scaleHor) )) - math.pi / 2)
    return latitude, longitude

def create_curve_from_coordinates(coordinates):
    """
    Create a curve in Blender based on a list of (x, y, z) coordinates.
    """

    pathThickness = bpy.context.scene.tp3d.pathThickness
    name = bpy.context.scene.tp3d.modelname

    # Create a new curve object
    curve_data = bpy.data.curves.new('GPX_Curve', type='CURVE')
    curve_data.dimensions = '3D'
    polyline = curve_data.splines.new('POLY')
    polyline.points.add(count=len(coordinates) - 1)

    # Populate the curve with points
    for i, coord in enumerate(coordinates):
        polyline.points[i].co = (coord[0], coord[1], coord[2], 1)  # (x, y, z, w)

    # Create an object with this curve
    curve_object = bpy.data.objects.new('GPX_Curve_Object', curve_data)
    bpy.context.collection.objects.link(curve_object)
    curve_object.data.bevel_depth = pathThickness/2  # Set the thickness of the curve
    curve_object.data.bevel_resolution = 4  # Set the resolution for smoothness
    
    mod = curve_object.modifiers.new(name="Remesh",type="REMESH")
    mod.mode = "VOXEL"
    mod.voxel_size = 0.05 * pathThickness * 10/2
    mod.adaptivity = 0.0
    curve_object.data.use_fill_caps = True
        
    curve_object.data.name = name + "_Trail"
    curve_object.name = name + "_Trail"
    
    
    curve_object.select_set(True)


    bpy.context.view_layer.objects.active = curve_object

    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.curve.select_all(action='SELECT')
    #bpy.ops.curve.smooth()
    bpy.ops.object.mode_set(mode='OBJECT')

    return curve_object



def simplify_curve(points_with_extra, min_distance=0.1000):
    """
    Removes points that are too close to any previously accepted point.
    Keeps the full (x, y, z, time) format.
    """

    if not points_with_extra:
        return []

    simplified = [points_with_extra[0]]
    last_xyz = Vector(points_with_extra[0][:3])
    skipped = 0

    for pt in points_with_extra[1:]:
        current_xyz = Vector(pt[:3])
        if (current_xyz - last_xyz).length >= min_distance:
            simplified.append(pt)
            last_xyz = current_xyz
        else:
            skipped += 1
            pass

    print(f"Smooth curve: Removed {skipped} vertices")
    return simplified

def create_hexagon(size, num_subdivisions = 1, name = "Hexagon"):
    """Creates a hexagon at (0,0,0), subdivides it, and rotates it by 90 degrees."""
    verts = []
    faces = []
    num_subdivisions = bpy.context.scene.tp3d.num_subdivisions

    for i in range(6):
        angle = math.radians(60 * i)
        x = size * math.cos(angle)
        y = size * math.sin(angle)
        verts.append((x, y, 0))
    verts.append((0, 0, 0))  # Center vertex
    faces = [[i, (i + 1) % 6, 6] for i in range(6)]
    mesh = bpy.data.meshes.new("Hexagon")
    obj = bpy.data.objects.new("Hexagon", mesh)
    bpy.context.collection.objects.link(obj)
    mesh.from_pydata(verts, [], faces)
    mesh.update()
    bpy.context.view_layer.objects.active = obj
    bpy.ops.object.mode_set(mode='EDIT')
    #bpy.ops.mesh.subdivide(number_cuts=num_subdivisions)
    for _ in range(num_subdivisions):
        bpy.ops.mesh.subdivide(number_cuts=1)  # 1 cut per loop for even refinement
    bpy.ops.object.mode_set(mode='OBJECT')
    obj.name = name
    obj.data.name = name
    return obj

def create_rectangle(width, height, num_subdivisions = 1, name="Rectangle"):
    """Creates a rectangle and adds loop cuts to ensure cells are as square as possible."""
    
    cuts = 1 + 2**(num_subdivisions+1)

    # 1. Create the basic plane mesh
    verts = [
        (-width / 2, -height / 2, 0), 
        (width / 2, -height / 2, 0), 
        (width / 2, height / 2, 0), 
        (-width / 2, height / 2, 0)
    ]
    faces = [[0, 1, 2, 3]]
    
    mesh = bpy.data.meshes.new(name)
    obj = bpy.data.objects.new(name, mesh)
    bpy.context.collection.objects.link(obj)
    mesh.from_pydata(verts, [], faces)
    mesh.update()
    
    # 2. Calculate cuts needed to keep cells square
    # Number of cuts = (Total Length / Cell Size) - 1
    # We use max(0, ...) to ensure we don't pass negative numbers
    target_cell_size = width/cuts
    cuts_y = max(0, int(round(height / target_cell_size)) - 1)
    
    # 3. Apply the cuts
    bpy.context.view_layer.objects.active = obj
    bpy.ops.object.mode_set(mode='EDIT')
    
    # Subdivide the edges differently for X and Y
    # We use the 'subdivide' operator but specify which edges to cut
    # by using the 'number_cuts' property twice on specific axes
    bm = bmesh.from_edit_mesh(mesh)
    
    # Subdivide horizontal edges (cuts along Width)
    horizontal_edges = [e for e in bm.edges if e.verts[0].co.y == e.verts[1].co.y]
    if num_subdivisions > 0:
        bmesh.ops.subdivide_edges(bm, edges=horizontal_edges, cuts=cuts, use_grid_fill=True)

    bm.verts.ensure_lookup_table()
    bm.edges.ensure_lookup_table()
    bm.faces.ensure_lookup_table()

    vertical_edges = [e for e in bm.edges if abs(e.verts[0].co.x - e.verts[1].co.x) < 0.001]
    if cuts_y > 0:
        bmesh.ops.subdivide_edges(bm, edges=vertical_edges, cuts=cuts_y, use_grid_fill=True)
        
    bmesh.update_edit_mesh(mesh)
    bpy.ops.object.mode_set(mode='OBJECT')
    
    return obj

def create_heart(size, num_subdivisions = 1, name = "Heart"):
    """Creates a full heart-shaped mesh in Blender and applies a Remesh modifier."""
    verts = []
    faces = []
    
    # Heart parametric equations (full heart)
    steps = 200
    for i in range(steps + 1):
        t = i / steps * (2 * math.pi)
        x = size * (16 * math.sin(t) ** 3) / 16
        y = size * (13 * math.cos(t) - 5 * math.cos(2 * t) - 2 * math.cos(3 * t) - math.cos(4 * t)) / 16
        verts.append((x, y, 0))
    
    # Add the center vertex for triangulation
    verts.append((0, -size / 2, 0))
    center_index = len(verts) - 1
    
    # Create faces
    for i in range(steps):
        faces.append([i, (i + 1) % steps, center_index])
    
    # Create the mesh
    mesh = bpy.data.meshes.new(name)
    obj = bpy.data.objects.new(name, mesh)
    bpy.context.collection.objects.link(obj)
    
    # Set the mesh data
    mesh.from_pydata(verts, [], faces)
    mesh.update()
    
    bpy.context.view_layer.objects.active = obj
    
    # Enter Edit mode
    bpy.ops.object.mode_set(mode='EDIT')

    # Extrude the surface
    bpy.ops.mesh.extrude_region_move(TRANSFORM_OT_translate={
        'value': (0, 0, 2)
    })
    
    bpy.ops.object.mode_set(mode='OBJECT')
    

    
    
    # Add Remesh modifier
    remesh = obj.modifiers.new(name="Remesh", type='REMESH')
    remesh.mode = 'SHARP'
    remesh.octree_depth = num_subdivisions + 1    
    remesh.scale = 0.9
    remesh.sharpness = 1.0 
    
    
    if "Remesh" in obj.modifiers:
        bpy.ops.object.modifier_apply(modifier="Remesh")
        
    bpy.ops.object.mode_set(mode='EDIT')
    
    
    # Get the mesh data
    mesh = obj.data
    bm = bmesh.new()
    bm.from_mesh(mesh)

    # Find the top coplanar faces
    bm.faces.ensure_lookup_table()
    top_faces = [f for f in bm.faces if f.normal == Vector((0, 0, 1))]

    top_normals = {tuple(f.normal) for f in top_faces}

    # Delete faces that are not coplanar with the top surfaces
    faces_to_delete = [f for f in bm.faces if tuple(f.normal) not in top_normals]

    bmesh.ops.delete(bm, geom=faces_to_delete, context='FACES')
    
    bpy.ops.object.mode_set(mode='OBJECT')
    
    # Update the mesh
    bm.to_mesh(mesh)
    mesh.update()
    bm.free()


    # Back to Object mode
    bpy.ops.object.mode_set(mode='OBJECT')
    
    
    return obj

def create_circle(radius, num_subdivisions = 1, name = "Circle", num_segments=64):
    
    # Ensure we are in Object Mode
    try:
        bpy.ops.object.mode_set(mode='OBJECT')
    except:
        pass

    # Create a new mesh and object
    mesh = bpy.data.meshes.new(name)
    obj = bpy.data.objects.new(name, mesh)
    

    # Link object to the scene collection
    bpy.context.collection.objects.link(obj)

    # Generate circle vertices
    verts = []
    faces = []
    
    for i in range(num_segments):
        angle = math.radians(360 * i / num_segments)
        x = radius * math.cos(angle)
        y = radius * math.sin(angle)
        verts.append((x, y, 0))

    # Create edges between consecutive points
    edges = [(i, (i + 1) % num_segments) for i in range(num_segments)]

    # Create the mesh from data
    mesh.from_pydata(verts, edges, [])  # No center vertex, no faces yet
    mesh.update()

    # Make the object active and switch to Edit Mode
    bpy.context.view_layer.objects.active = obj
    bpy.ops.object.mode_set(mode='EDIT')

    # Select all vertices and fill the circle
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.mesh.fill_grid()
    
    #bpy.ops.mesh.subdivide(number_cuts=max(int(num_subdivisions/15),0))
    for _ in range(num_subdivisions-3):
        bpy.ops.mesh.subdivide(number_cuts=1)  # 1 cut per loop for even refinement

    # Switch back to Object Mode
    bpy.ops.object.mode_set(mode='OBJECT')

    return obj

def create_ellipse(radius, num_subdivisions = 1, name = "Ellipse", aspect_ratio = 0.75, num_segments=64, ):
    # Ensure we are in Object Mode
    try:
        bpy.ops.object.mode_set(mode='OBJECT')
    except:
        pass

    # Create a new mesh and object
    mesh = bpy.data.meshes.new(name)
    obj = bpy.data.objects.new(name, mesh)
    

    # Link object to the scene collection
    bpy.context.collection.objects.link(obj)

    # Generate circle vertices
    verts = []
    faces = []
    
    for i in range(num_segments):
        angle = math.radians(360 * i / num_segments)
        x = radius * math.cos(angle)
        y = radius * math.sin(angle)
        verts.append((x, y, 0))

    # Create edges between consecutive points
    edges = [(i, (i + 1) % num_segments) for i in range(num_segments)]

    # Create the mesh from data
    mesh.from_pydata(verts, edges, [])  # No center vertex, no faces yet
    mesh.update()

    # Make the object active and switch to Edit Mode
    bpy.context.view_layer.objects.active = obj
    bpy.ops.object.mode_set(mode='EDIT')

    # Select all vertices and fill the circle
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.mesh.fill_grid()
    
    #bpy.ops.mesh.subdivide(number_cuts=max(int(num_subdivisions/15),0))
    for _ in range(num_subdivisions-3):
        bpy.ops.mesh.subdivide(number_cuts=1)  # 1 cut per loop for even refinement

    # Switch back to Object Mode
    bpy.ops.object.mode_set(mode='OBJECT')

    obj.scale.y *= aspect_ratio

    bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)


    return obj

def create_octagon(size, num_subdivisions = 1, name = "Octagon"):

    """Creates a hexagon at (0,0,0), subdivides it, and rotates it by 90 degrees."""
    verts = []
    faces = []
    for i in range(8):
        angle = math.radians(45 * i + 22.5)
        x = size * math.cos(angle)
        y = size * math.sin(angle)
        verts.append((x, y, 0))
    verts.append((0, 0, 0))  # Center vertex
    faces = [[i, (i + 1) % 8, 8] for i in range(8)]
    mesh = bpy.data.meshes.new("Hexagon")
    obj = bpy.data.objects.new("Hexagon", mesh)
    bpy.context.collection.objects.link(obj)
    mesh.from_pydata(verts, [], faces)
    mesh.update()
    bpy.context.view_layer.objects.active = obj
    bpy.ops.object.mode_set(mode='EDIT')
    #bpy.ops.mesh.subdivide(number_cuts=num_subdivisions)
    for _ in range(num_subdivisions):
        bpy.ops.mesh.subdivide(number_cuts=1)  # 1 cut per loop for even refinement
    bpy.ops.object.mode_set(mode='OBJECT')
    obj.name = name
    obj.data.name = name
    return obj

# Get real elevation for a point
def get_elevation_single(lat, lon):
    """Fetches real elevation for a single latitude and longitude using OpenTopoData."""

    dataset = bpy.context.scene.tp3d.dataset

    url = f"https://api.opentopodata.org/v1/{dataset}?locations={lat},{lon}"
    response = requests.get(url).json()
    elevation = response['results'][0]['elevation'] if 'results' in response else 0
    return elevation  # Scale down elevation to match Blender terrain


def get_elevation_openTopoData(coords, lenv = 0, pointsDone = 0, progress_cb=None):
    """Fetches real elevation for each vertex using OpenTopoData with request batching."""

    disableCache = bpy.context.scene.tp3d.disableCache
    opentopoAdress = bpy.context.scene.tp3d.opentopoAdress
    dataset = bpy.context.scene.tp3d.dataset

    # Ensure the cache is loaded
    if not const._elevation_cache:
        load_elevation_cache()

    # First, check which coordinates need fetching (not in cache)
    coords_to_fetch = []
    coords_indices = []

    elevations = [0] * len(coords)  # Pre-allocate list


    #check if coordinates are in cache or not
    for i, (lat, lon) in enumerate(coords):
        cached_elevation = get_cached_elevation(lat, lon)
        if cached_elevation is not None and disableCache == 0:
            # Use cached elevation
            elevations[i] = cached_elevation
        else:
            # Need to fetch this coordinate
            elevations[i] = -5
            coords_to_fetch.append((lat, lon))
            coords_indices.append(i)

    if len(coords) - len(coords_to_fetch) > 0:
        print(f"Using: {len(coords) - len(coords_to_fetch)} cached Coordinates")
    
    # If all elevations were found in cache, return immediately
    if not coords_to_fetch:
        if progress_cb:
            progress_cb(100)
        return elevations

    #coords = [convert_to_geo(y, x, v[0], v[1]) for v in vertices]
    #elevations = []
    batch_size = 10
    progress_intervals = set(range(5, 101, 5))
    total_to_fetch = len(coords_to_fetch)
    for i in range(0, total_to_fetch, batch_size):
        batch = coords_to_fetch[i:i + batch_size]
        query = "|".join([f"{c[0]},{c[1]}" for c in batch])
        url = f"{opentopoAdress}{dataset}?locations={query}"
        last_request_time = time.monotonic()
        response = requests.get(url)
        nr = i + len(batch) + pointsDone
        addition = f" {nr}/{int(lenv)}"
        send_api_request(addition)
        pct = int(min((i + len(batch)) / total_to_fetch * 100, 100))
        for threshold in sorted(t for t in progress_intervals if pct >= t):
            if progress_cb:
                progress_cb(threshold)
                #print(f"Opentopodata: Fetching {i}/{total_to_fetch}")
            progress_intervals.discard(threshold)
        response.raise_for_status()
        
        
        data = response.json()
        # Handle the elevation data and replace 'null' with 0
        for o, result in enumerate(data['results']):
            elevation = result.get('elevation', None)  # Safe get, default to None if key is missing
            if elevation is None:
                elevation = 0  # Replace None (null in JSON) with 0
            cache_elevation(batch[o][0], batch[o][1], elevation)
            ind = coords_indices[i+o]
            elevations[ind] = elevation
        
        # Get current time
        now = time.monotonic()  # Monotonic time is safer for measuring elapsed time
        elapsed_time = now - last_request_time
        if i + batch_size < len(coords_to_fetch) and elapsed_time < 1.3:
            time.sleep(1.3 - elapsed_time)  # Pause to prevent request throttling

    return elevations

def get_elevation_openElevation(coords, lenv = 0, pointsDone = 0, progress_cb=None):
    """Fetches real elevation for each vertex using Open-Elevation with request batching."""

    elevations = []
    batch_size = 1000
    total = len(coords)
    progress_intervals = set(range(5, 101, 5))
    for i in range(0, total, batch_size):
        batch = coords[i:i + batch_size]
        # Open-Elevation expects a POST request with JSON body
        payload = {"locations": [{"latitude": c[0], "longitude": c[1]} for c in batch]}
        url = "https://api.open-elevation.com/api/v1/lookup"
        last_request_time = time.monotonic()

        headers = {'Content-Type': 'application/json'}
        nr = i + len(batch) + pointsDone
        addition = f" {nr}/{int(lenv)}"
        send_api_request(addition)
        pct = int(min((i + len(batch)) / total * 100, 100))
        for threshold in sorted(t for t in progress_intervals if pct >= t):
            if progress_cb:
                progress_cb(threshold)
            progress_intervals.discard(threshold)
        
        response = requests.post(url, json=payload, headers=headers)
        
        #print(url)
        #print(payload)
        
        response.raise_for_status()

        data = response.json()
        
        
        # Handle the elevation data and replace 'null' with 0
        for result in data['results']:
            elevation = result.get('elevation', None)
            if elevation is None:
                elevation = 0
            elevations.append(elevation)
        
        # Get current time for request rate limiting
        now = time.monotonic()  
        elapsed_time = now - last_request_time
        if elapsed_time < 2:
            time.sleep(2 - elapsed_time)  # Pause to prevent request throttling

    return elevations

def lonlat_to_tilexy(lon, lat, zoom):
    lat_rad = math.radians(lat)
    n = 2.0 ** zoom
    xtile = int((lon + 180.0) / 360.0 * n)
    ytile = int((1.0 - math.log(math.tan(lat_rad) + 1.0 / math.cos(lat_rad)) / math.pi) / 2.0 * n)
    return xtile, ytile

def lonlat_to_pixelxy(lon, lat, zoom):
    lat_rad = math.radians(lat)
    n = 2.0 ** zoom
    x = (lon + 180.0) / 360.0 * n * 256
    y = (1.0 - math.log(math.tan(lat_rad) + 1.0 / math.cos(lat_rad)) / math.pi) / 2.0 * n * 256
    return int(x % 256), int(y % 256)

def fetch_terrarium_tile_raw(zoom, xtile, ytile):
    """Fetch the raw PNG binary data for a tile, either from cache or online."""
    tile_path = os.path.join(const.terrarium_cache_dir, f"{zoom}_{xtile}_{ytile}.png")
    if not os.path.exists(tile_path):
        url = f"https://elevation-tiles-prod.s3.amazonaws.com/terrarium/{zoom}/{xtile}/{ytile}.png"
        #print("Sending Request")
        response = requests.get(url)
        response.raise_for_status()
        with open(tile_path, "wb") as f:
            f.write(response.content)
    with open(tile_path, "rb") as f:
        return f.read()

def paeth_predictor(a, b, c):
    # PNG Paeth filter
    p = a + b - c
    pa = abs(p - a)
    pb = abs(p - b)
    pc = abs(p - c)
    if pa <= pb and pa <= pc:
        return a
    elif pb <= pc:
        return b
    else:
        return c

def parse_png_rgb_data(png_bytes):
    """Extract uncompressed RGB bytes from a PNG image (supports all PNG filter types)."""
    assert png_bytes[:8] == b'\x89PNG\r\n\x1a\n', "Not a valid PNG file"
    offset = 8
    width = height = None
    idat_data = b''

    while offset < len(png_bytes):
        length = struct.unpack(">I", png_bytes[offset:offset+4])[0]
        chunk_type = png_bytes[offset+4:offset+8]
        data = png_bytes[offset+8:offset+8+length]
        offset += 12 + length

        if chunk_type == b'IHDR':
            width, height, bit_depth, color_type, _, _, _ = struct.unpack(">IIBBBBB", data)
            assert bit_depth == 8 and color_type == 2, "Only 8-bit RGB PNGs supported"
        elif chunk_type == b'IDAT':
            idat_data += data
        elif chunk_type == b'IEND':
            break

    raw = zlib.decompress(idat_data)
    stride = 3 * width
    rgb_array = []
    prev_row = bytearray(stride)

    for y in range(height):
        i = y * (stride + 1)
        filter_type = raw[i]
        scanline = bytearray(raw[i + 1:i + 1 + stride])
        recon = bytearray(stride)

        if filter_type == 0:
            recon[:] = scanline
        elif filter_type == 1:  # Sub
            for i in range(stride):
                val = scanline[i]
                left = recon[i - 3] if i >= 3 else 0
                recon[i] = (val + left) % 256
        elif filter_type == 2:  # Up
            for i in range(stride):
                recon[i] = (scanline[i] + prev_row[i]) % 256
        elif filter_type == 3:  # Average
            for i in range(stride):
                left = recon[i - 3] if i >= 3 else 0
                up = prev_row[i]
                recon[i] = (scanline[i] + (left + up) // 2) % 256
        elif filter_type == 4:  # Paeth
            for i in range(stride):
                a = recon[i - 3] if i >= 3 else 0
                b = prev_row[i]
                c = prev_row[i - 3] if i >= 3 else 0
                recon[i] = (scanline[i] + paeth_predictor(a, b, c)) % 256
        else:
            raise ValueError(f"Unsupported filter type {filter_type}")

        # Convert scanline to list of (R, G, B) tuples
        row = [(recon[i], recon[i+1], recon[i+2]) for i in range(0, stride, 3)]
        rgb_array.append(row)
        prev_row = recon

    return rgb_array


def terrarium_pixel_to_elevation(r, g, b):
    """Convert Terrarium RGB pixel to elevation in meters."""
    return (r * 256 + g + b / 256) - 32768

def get_elevation_TerrainTiles(coords, lenv=0, pointsDone=0, zoom=10, progress_cb=None):

    num_subdivisions = bpy.context.scene.tp3d.num_subdivisions
    minLat = bpy.context.scene.tp3d.minLat
    minLon = bpy.context.scene.tp3d.minLon
    maxLat = bpy.context.scene.tp3d.maxLat
    maxLon = bpy.context.scene.tp3d.maxLon
    

    #Each Tile requested is a PNG that is 256x256 Pixels big

    realdist1 = haversine(minLat,minLon,minLat,maxLon)*1000
    realdist2 = haversine(maxLat,minLon,maxLat,maxLon)*1000
    #calculating zoom
    zoom = 10
    horVerts = 1 + 2**(num_subdivisions+1)
    dist = 25.00000 / 2**(num_subdivisions-1) #25 is the rough distance between verts on resolution 1
    strt = 156543 #m/Pixel on Tile PNG
    #print(f"dist:{dist}")
    cntr = 2

    #print(f"scaleHor: {scaleHor}")
    vertdist = max(realdist1,realdist2)/horVerts #Distance between 2 vertices
    while strt > vertdist:
        cntr += 1
        strt /= 2
        #print(f"halved: {strt:.2f}, {cntr}, {vertdist:.2f}")
    #Max zoom level to 14
    cntr = min(cntr,15)

    #print(f"horVerts: {horVerts}")
    print(f"Zoom Level for API: {cntr}, Start fetching Data...")
        #print(f"calculated distance: {dist}")
    zoom = cntr
    
    
    


    tile_dict = {}
    for idx, (lat, lon) in enumerate(coords):
        xtile, ytile = lonlat_to_tilexy(lon, lat, zoom)
        tile_dict.setdefault((xtile, ytile), []).append((idx, lat, lon))

    total_tiles = len(tile_dict)
    progress_intervals = set(range(10,101,10))
    elevations = [0] * len(coords)
    for i, ((xtile, ytile), idx_lat_lon_list) in enumerate(tile_dict.items(), 1):
        percent_complete = int((i/ total_tiles) * 100)
        if percent_complete in progress_intervals:
            print(f"{datetime.now().strftime('%H:%M:%S')} - Elevation {percent_complete}% complete, {i}")
            progress_intervals.remove(percent_complete)
            if progress_cb:
                progress_cb(percent_complete)
        try:
            png_bytes = fetch_terrarium_tile_raw(zoom, xtile, ytile)
            rgb_array = parse_png_rgb_data(png_bytes)
        except Exception as e:
            print(f"Failed to fetch or parse tile {zoom}/{xtile}/{ytile}: {e}")
            for idx, _, _ in idx_lat_lon_list:
                elevations[idx] = 0
            continue

        for idx, lat, lon in idx_lat_lon_list:
            px, py = lonlat_to_pixelxy(lon, lat, zoom)
            px = min(max(px, 0), 255)
            py = min(max(py, 0), 255)
            r, g, b = rgb_array[py][px]
            temp_ele = terrarium_pixel_to_elevation(r, g, b)
            if temp_ele < -50:
                temp_ele = -1
                buggyDataset = 1
                bpy.context.scene.tp3d.buggyDataset = buggyDataset
            elevations[idx] = temp_ele

            

    return elevations


def get_elevation_openTopography(coords, lenv=0, pointsDone=0, progress_cb=None):
    """Fetch elevation using the OpenTopography Global DEM API.

    Downloads an ASCII Grid DEM for the coordinate bounding box in a single
    request, then samples the grid at each coordinate.  Supports all
    OpenTopography Global DEM datasets; SRTMGL3 and SRTM15Plus are free and
    work without an API key.
    """
    if not coords:
        return []

    tp3d    = bpy.context.scene.tp3d
    from .addon_preferences import get_prefs
    api_key = get_prefs().openTopographyApiKey
    demtype = tp3d.openTopographyDataset

    lats  = [c[0] for c in coords]
    lons  = [c[1] for c in coords]
    pad   = 0.005          # small padding so border verts don't fall outside the grid
    south = min(lats) - pad
    north = max(lats) + pad
    west  = min(lons) - pad
    east  = max(lons) + pad

    if progress_cb:
        progress_cb(5)

    params = {
        "demtype":      demtype,
        "south":        f"{south:.6f}",
        "north":        f"{north:.6f}",
        "west":         f"{west:.6f}",
        "east":         f"{east:.6f}",
        "outputFormat": "AAIGrid",
    }
    if api_key:
        params["API_Key"] = api_key

    print(f"OpenTopography: requesting {demtype} DEM "
          f"({south:.3f},{west:.3f})→({north:.3f},{east:.3f}, {len(coords)} coordinates)")

    try:
        response = requests.get(
            "https://portal.opentopography.org/API/globaldem",
            params=params,
            timeout=180,
        )
        if response.status_code == 401:
            _progress.WarningsOverlay.add_warning(
                "OpenTopography: invalid or missing API key (401). "
                "Get a free key at portal.opentopography.org", "error")
            return [0.0] * len(coords)
        response.raise_for_status()
    except requests.exceptions.RequestException as e:
        _progress.WarningsOverlay.add_warning(
            f"OpenTopography: request failed — {e}", "error")
        return [0.0] * len(coords)

    if progress_cb:
        progress_cb(50)

    # The API returns either a plain-text .asc file or (rarely) a ZIP archive.
    content = response.content
    try:
        with zipfile.ZipFile(io.BytesIO(content)) as zf:
            asc_name = next((n for n in zf.namelist() if n.lower().endswith('.asc')), None)
            if asc_name is None:
                _progress.WarningsOverlay.add_warning(
                    "OpenTopography: no .asc file found in ZIP response", "error")
                return [0.0] * len(coords)
            asc_data = zf.read(asc_name).decode('utf-8')
    except zipfile.BadZipFile:
        # Plain-text .asc response
        try:
            asc_data = content.decode('utf-8')
        except Exception as e:
            _progress.WarningsOverlay.add_warning(
                f"OpenTopography: could not decode response — {e}", "error")
            return [0.0] * len(coords)
        # Sanity-check: if it looks like an error page rather than a grid, bail out
        if 'ncols' not in asc_data[:500].lower():
            print(f"OpenTopography unexpected response: {asc_data[:300]}")
            _progress.WarningsOverlay.add_warning(
                "OpenTopography: unexpected response format (check API key / bbox)", "error")
            return [0.0] * len(coords)

    # --- Parse ASCII Grid header ---
    lines      = asc_data.strip().splitlines()
    header     = {}
    data_start = 0
    for i, line in enumerate(lines):
        parts = line.strip().split()
        if len(parts) >= 2 and not parts[0][0].lstrip('-').replace('.', '').isdigit():
            header[parts[0].lower()] = float(parts[1])
            data_start = i + 1
        else:
            data_start = i
            break

    ncols    = int(header.get('ncols', 0))
    nrows    = int(header.get('nrows', 0))
    xll      = header.get('xllcenter', header.get('xllcorner', west))
    yll      = header.get('yllcenter', header.get('yllcorner', south))
    cellsize = header.get('cellsize', 1.0)
    nodata   = header.get('nodata_value', header.get('nodata', -9999.0))

    if ncols == 0 or nrows == 0 or cellsize == 0:
        print("OpenTopography: empty or invalid DEM grid — returning zeros")
        return [0.0] * len(coords)

    # --- Load grid rows (row 0 = northernmost row) ---
    grid_rows = []
    for line in lines[data_start:]:
        vals = line.strip().split()
        if vals:
            grid_rows.append([float(v) for v in vals])

    if progress_cb:
        progress_cb(80)

    def _sample(lat, lon):
        col_i = int(round((lon - xll) / cellsize))
        row_i = int(round((nrows - 1) - (lat - yll) / cellsize))
        col_i = max(0, min(col_i, ncols - 1))
        row_i = max(0, min(row_i, nrows - 1))
        if row_i < len(grid_rows) and col_i < len(grid_rows[row_i]):
            val = grid_rows[row_i][col_i]
            return 0.0 if val == nodata else float(val)
        return 0.0

    elevations = [_sample(lat, lon) for lat, lon in coords]

    if progress_cb:
        progress_cb(100)

    print(f"OpenTopography: sampled {len(elevations)} elevations "
          f"from {nrows}×{ncols} grid (cellsize={cellsize}°)")
    return elevations


def get_elevation_path_openElevation(vertices):
    """Fetches real elevation for each vertex using OpenTopoData with request batching."""
    v = vertices
    coords = [(v[0], v[1], v[2], v[3]) for v in vertices]
    elevations = []
    batch_size = 1000
    for i in range(0, len(coords), batch_size):
        batch = coords[i:i + batch_size]
        # Open-Elevation expects a POST request with JSON body
        payload = {"locations": [{"latitude": c[0], "longitude": c[1]} for c in batch]}
        url = "https://api.open-elevation.com/api/v1/lookup"
        last_request_time = time.monotonic()
        
        headers = {'Content-Type': 'application/json'}

        addition = f"(overwrite path) {i + len(batch)}/{len(coords)}"
        send_api_request(addition)

        response = requests.post(url, json=payload, headers=headers)
        
        #print(url)
        #print(payload)
        
        response.raise_for_status()

        data = response.json()
        
        elevations.extend([r['elevation'] for r in data['results']])
        now = time.monotonic()  # Monotonic time is safer for measuring elapsed time
        elapsed_time = now - last_request_time
        if i + batch_size < len(coords) and elapsed_time < 1.4:
            time.sleep(1.4 - elapsed_time)  # Pause to prevent request throttling
    
    for i in range(len(vertices)):
        coords[i] =  (coords[i][0], coords[i][1], elevations[i], coords[i][3])
        #print(elevations[i])
    
    return coords
# Get real elevation for each vertex

def get_elevation_path_openTopoData(vertices):

    opentopoAdress = bpy.context.scene.tp3d.opentopoAdress
    dataset = bpy.context.scene.tp3d.dataset

    print("Getting elevation")
    """Fetches real elevation for each vertex using OpenTopoData with request batching."""
    v = vertices
    coords = [(v[0], v[1], v[2], v[3]) for v in vertices]
    elevations = []
    batch_size = 100
    for i in range(0, len(coords), batch_size):
        batch = coords[i:i + batch_size]
        query = "|".join([f"{c[0]},{c[1]}" for c in batch])
        url = f"{opentopoAdress}{dataset}?locations={query}"
        last_request_time = time.monotonic()
        response = requests.get(url).json()
        addition = f"(overwrite path) {i + len(batch)}/{len(coords)}"
        send_api_request(addition)
        
        #elevations.extend([r['elevation'] for r in response['results']])
        elevations.extend([r.get('elevation') or 0 for r in response['results']])

        now = time.monotonic()  # Monotonic time is safer for measuring elapsed time
        elapsed_time = now - last_request_time
        if i + batch_size < len(coords) and elapsed_time < 1.4:
            time.sleep(1.4 - elapsed_time)  # Pause to prevent request throttling
    
    for i in range(len(vertices)):
        coords[i] =  (coords[i][0], coords[i][1], elevations[i], coords[i][3])
        #print(elevations[i])
    
    return coords


def RaycastPointToMeshZ(point, mesh_obj, offset_z=1000.0):
    """
    Raycast downward from a point onto a mesh and return the hit Z value.

    :param point: Vector or tuple (x, y, z)
    :param mesh_obj: Blender mesh object to raycast against
    :param offset_z: How far up to move the ray start before casting down
    :return: float Z value of hit location in world space, or None if no hit
    """

    point = Vector(point)

    # Move start point up so we can raycast downward
    ray_origin_world = point + Vector((0, 0, offset_z))
    ray_direction_world = Vector((0, 0, -1))

    # Get evaluated mesh (important for modifiers)
    depsgraph = bpy.context.evaluated_depsgraph_get()
    eval_mesh_obj = mesh_obj.evaluated_get(depsgraph)

    # Transform into mesh local space
    mesh_world = eval_mesh_obj.matrix_world
    mesh_world_inv = mesh_world.inverted()

    ray_origin_local = mesh_world_inv @ ray_origin_world
    ray_direction_local = (mesh_world_inv.to_3x3() @ ray_direction_world).normalized()

    # Raycast
    success, hit_loc, normal, face_index = eval_mesh_obj.ray_cast(
        ray_origin_local,
        ray_direction_local
    )

    if not success:
        return None

    # Convert hit back to world space
    hit_world = mesh_world @ hit_loc

    return hit_world.z


def RaycastCurveToMesh(curve_obj, mesh_obj):
    
    #MOVE EVERY POINT UP BY 100 SO ITS POSSIBLE TO RAYCAST IT DOWNARDS ONTO THE MESH
    offset = Vector((0, 0, 1000))
    for spline in curve_obj.data.splines:
        if spline.type == 'BEZIER':
            for p in spline.bezier_points:
                p.co += offset
                # if you want to move the handles too:
                p.handle_left += offset
                p.handle_right += offset
        else:  # POLY / NURBS
            for p in spline.points:
                p.co = (p.co.x, p.co.y, p.co.z + offset.z, p.co.w)

    depsgraph = bpy.context.evaluated_depsgraph_get()
    eval_mesh_obj = mesh_obj.evaluated_get(depsgraph)

    curve_world     = curve_obj.matrix_world
    curve_world_inv = curve_world.inverted()

    mesh_world     = eval_mesh_obj.matrix_world
    mesh_world_inv = mesh_world.inverted()

    direction_world = Vector((0, 0, -1))  # world -Z
    direction_local = (mesh_world_inv.to_3x3() @ direction_world).normalized()

    for spline in curve_obj.data.splines:
        if spline.type == 'BEZIER':
            points = spline.bezier_points
        else:
            points = spline.points

        for point in points:
            # world-space position of curve point
            if spline.type == 'BEZIER':
                co_world = curve_world @ point.co
            else:
                co_world = curve_world @ point.co.xyz

            # convert origin to mesh local
            co_local = mesh_world_inv @ co_world

            # raycast in mesh local space
            success, hit_loc, normal, face_index = eval_mesh_obj.ray_cast(co_local, direction_local)

            if success:
                # back to world space
                hit_world = mesh_world @ hit_loc
                # then into curve local
                local_hit = curve_world_inv @ hit_world

                if spline.type == 'BEZIER':
                    point.co = local_hit
                    point.handle_left_type = point.handle_right_type = 'AUTO'
                else:
                    point.co = (local_hit.x, local_hit.y, local_hit.z, 1.0)
            else:
                point.co -= Vector((offset.x, offset.y, offset.z, 1.0))
    
    bpy.context.view_layer.objects.active = curve_obj
    bpy.ops.object.mode_set(mode='EDIT')

    # select all points if you want to smooth everything
    bpy.ops.curve.select_all(action='SELECT')

    # run the smooth operator
    bpy.ops.curve.smooth()

    # back to Object Mode if you like
    bpy.ops.object.mode_set(mode='OBJECT')

    print("Path Elevation Overwritten")

def RaycastCurveToAnyMesh(curve_obj, offset_z=1000.0, smooth_after=True):
    """Move curve points up by offset_z then raycast straight down onto any mesh below.
    Uses scene.ray_cast so the nearest mesh hit is used automatically.
    """

    scene = bpy.context.scene
    depsgraph = bpy.context.evaluated_depsgraph_get()

    offset = Vector((0.0, 0.0, offset_z))

    # Move points up by offset so we can raycast downwards
    for spline in curve_obj.data.splines:
        if spline.type == 'BEZIER':
            for p in spline.bezier_points:
                p.co += offset
                p.handle_left += offset
                p.handle_right += offset
        else:  # POLY / NURBS
            for p in spline.points:
                # p.co is (x, y, z, w)
                p.co = (p.co.x, p.co.y, p.co.z + offset_z, p.co.w)

    curve_world     = curve_obj.matrix_world
    curve_world_inv = curve_world.inverted()

    # ray direction in world space: straight down
    direction_world = Vector((0.0, 0.0, -1.0))

    for spline in curve_obj.data.splines:
        if spline.type == 'BEZIER':
            points = spline.bezier_points
        else:
            points = spline.points

        for point in points:
            # get world-space position of the point
            if spline.type == 'BEZIER':
                co_world = curve_world @ point.co
            else:
                co_world = curve_world @ point.co.xyz

            # cast ray from this origin straight down in world-space
            # scene.ray_cast returns (result, location, normal, face_index, object, matrix)
            hit_result = scene.ray_cast(depsgraph, co_world, direction_world)
            hit_success = hit_result[0]

            if hit_success:
                hit_loc_world = hit_result[1]

                # convert hit back into curve local space
                local_hit = curve_world_inv @ hit_loc_world

                if spline.type == 'BEZIER':
                    point.co = local_hit
                    # keep handles auto to get a reasonable shape; alternatively compute
                    point.handle_left_type = point.handle_right_type = 'AUTO'
                else:
                    # preserve w component
                    w = getattr(point.co, "w", 1.0)
                    point.co = (local_hit.x, local_hit.y, local_hit.z, w)

    # optional smoothing (go into edit mode, smooth, come back)
    if smooth_after:
        bpy.context.view_layer.objects.active = curve_obj
        bpy.ops.object.mode_set(mode='EDIT')
        bpy.ops.curve.select_all(action='SELECT')
        bpy.ops.curve.smooth()
        bpy.ops.object.mode_set(mode='OBJECT')




# Get tile elevation
def get_tile_elevation(obj, progress_cb=None):

    mesh = obj.data
    api = bpy.context.scene.tp3d.api


    # Set chunk size based on API
    if api == "OPENTOPODATA" or api == "OPEN-ELEVATION":
        chunk_size = 100000
    elif api == "TERRAIN-TILES" or api == "OPENTOPOGRAPHY":
        chunk_size = 50000000   # single request for all verts
    else:
        chunk_size = 100000  # fallback

    vertices = list(mesh.vertices)
    obj_matrix = obj.matrix_world

    # Convert all vertex positions to world space
    world_verts = [obj_matrix @ v.co for v in vertices]

    # Get min/max bounds in world space
    min_x = min(v.x for v in world_verts)
    max_x = max(v.x for v in world_verts)
    min_y = min(v.y for v in world_verts)
    max_y = max(v.y for v in world_verts)


    # Use object's world location as reference origin
    origin_lat = obj_matrix.translation.y
    origin_lon = obj_matrix.translation.x

    minl = convert_to_geo(min_x, min_y)
    maxl = convert_to_geo(max_x, max_y)

    minLat = minl[0]
    maxLat = maxl[0]
    minLon = minl[1]
    maxLon = maxl[1]




    realdist1 = haversine(minLat,minLon,maxLat,maxLon)*1
    realdist2 = haversine(minLat,minLon,maxLat,maxLon)*1

    bpy.context.scene.tp3d["sMapInKm"] = max(realdist1,realdist2)
    bpy.context.scene.tp3d["minLat"] = minLat
    bpy.context.scene.tp3d.maxLat = maxLat
    bpy.context.scene.tp3d.minLon = minLon
    bpy.context.scene.tp3d.maxLon = maxLon


    elevations = []
    for i in range(0, len(world_verts), chunk_size):
        chunk = world_verts[i:i + chunk_size]

        coords = [convert_to_geo(v.x, v.y) for v in chunk]
        if api == "OPENTOPODATA":
            chunk_elevations = get_elevation_openTopoData(coords, len(vertices), i, progress_cb=progress_cb)
        elif api == "OPEN-ELEVATION":
            chunk_elevations = get_elevation_openElevation(coords, len(vertices), i, progress_cb=progress_cb)
        elif api == "TERRAIN-TILES":
            chunk_elevations = get_elevation_TerrainTiles(coords, len(vertices), i, progress_cb=progress_cb)
        elif api == "OPENTOPOGRAPHY":
            chunk_elevations = get_elevation_openTopography(coords, len(vertices), i, progress_cb=progress_cb)
        else:
            chunk_elevations = [0.0] * len(chunk)  # fallback

        elevations.extend(chunk_elevations)

        # Free memory after processing chunk
        del chunk_elevations

    save_elevation_cache()

    lowestZ = min(elevations)
    highestZ = max(elevations)
    additionalExtrusion = lowestZ
    diff = highestZ - lowestZ

    bpy.context.scene.tp3d["o_verticesMap"] = str(len(mesh.vertices))
    bpy.context.scene.tp3d.lowestZ = lowestZ
    bpy.context.scene.tp3d.highestZ = highestZ
    bpy.context.scene.tp3d.sAdditionalExtrusion = additionalExtrusion

    return elevations, diff

# Transform MapObject
def transform_MapObject(obj, newX, newY):
    obj.location.x += newX
    obj.location.y += newY

def haversine(lat1, lon1, lat2, lon2):
    """Calculates the great-circle distance between two points using the Haversine formula."""

    R = const.R
    phi1 = math.radians(lat1)
    phi2 = math.radians(lat2)
    delta_phi = math.radians(lat2 - lat1)
    delta_lambda = math.radians(lon2 - lon1)

    a = math.sin(delta_phi / 2)**2 + math.cos(phi1) * math.cos(phi2) * math.sin(delta_lambda / 2)**2
    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
    distance = R * c  # distance in kilometers
    #print(f"Distance between 2 points: {distance}")
    return distance
    
    
def calculate_total_length(points):
    #Calculates the total path length in kilometers.
    total_distance = 0.0
    for i in range(1, len(points)):
        lon1, lat1, _, _ = points[i - 1]
        lon2, lat2, _, _ = points[i]
        total_distance += haversine(lon1, lat1, lon2, lat2)
    return total_distance

def calculate_total_elevation(points):
    #Calculates the total elevation gain in meters.
    total_elevation = 0.0
    for i in range(1, len(points)):
        _, _, elev1, _ = points[i - 1]
        _, _, elev2, _ = points[i]
        if elev2 > elev1:
            total_elevation += elev2 - elev1
    return total_elevation

def calculate_total_time(points):
    hrs = 0
    #Calculates the total time taken between the first and last points.
    if len(points) < 2:
        return 0.0
    st = points[0][3]
    et = points[-1][3]
    if st != None and et != None:
        time_diff = et - st
        hrs = time_diff.total_seconds() / 3600
    
    return hrs

def calculate_date(points):
    hrs = 0
    #Calculates the total time taken between the first and last points.
    if len(points) < 2:
        return ""
    st = points[0][3]
    print(st)
    print(type(st))
    
    #date = datetime.fromisoformat(start_time.replace("Z","")).strftime("%Y-%m-%d")
    if st:
        dt = str(st.date())
    else:
        dt = ""
    
    return dt

def update_text_object(obj_name, new_text):
    """Updates the text of a Blender text object."""
    text_obj = bpy.data.objects.get(obj_name)
    if text_obj and text_obj.type == 'FONT':
        text_obj.data.body = new_text
        

def zoom_camera_to_selected(obj):
    
    bpy.ops.object.select_all(action='DESELECT')
    
    obj.select_set(True)  # Select the object
    
    area = [area for area in bpy.context.screen.areas if area.type == "VIEW_3D"][0]
    region = area.regions[-1]

    with bpy.context.temp_override(area=area, region=region):
        bpy.ops.view3d.view_selected(use_all_regions=False)
        
        
def create_text(name, text, position, scale_multiplier, rotation=(0, 0, 0), extrude=20):
    txt_data = bpy.data.curves.new(name=name, type='FONT')
    txt_obj = bpy.data.objects.new(name=name, object_data=txt_data)
    bpy.context.collection.objects.link(txt_obj)
    
    textFont = bpy.context.scene.tp3d.textFont

    if textFont == "":
        if platform.system() == "Windows":
            textFont = "C:/WINDOWS/FONTS/ariblk.ttf"
        elif platform.system() == "Darwin":
            textFont = "/System/Library/Fonts/Supplemental/Arial Black.ttf"
        else:
            textFont = ""

    txt_data.body = text
    txt_data.extrude = extrude
    #txt_data.font = bpy.data.fonts.load("C:/Windows/Fonts/ariblk.ttf")  # Adjust path if needed
    txt_data.font = bpy.data.fonts.load(textFont)
    txt_data.align_x = 'CENTER'
    txt_data.align_y = "CENTER"
    
    txt_obj.scale = (scale_multiplier, scale_multiplier, 1)
    txt_obj.location = position
    txt_obj.rotation_euler = rotation
    
    txt_obj.location.z -= 1
    
    return txt_obj


def appendTextIcon(textobject, icon, scaleM= 1):

    addon_dir = os.path.dirname(__file__)
    filepath = os.path.join(addon_dir, "assets", "other.blend")

    object_name = icon

    # Remove existing object with the same name (optional)
    old_obj = bpy.data.objects.get(object_name)
    if old_obj:
        bpy.data.objects.remove(old_obj, do_unlink=True)

    # Append the object from the blend file
    with bpy.data.libraries.load(filepath, link=False) as (data_from, data_to):
        if object_name in data_from.objects:
            data_to.objects.append(object_name)
        else:
            print(f"Object '{object_name}' not found in file.")
            return None

    # Get the appended object
    obj = bpy.data.objects.get(object_name)
    if not obj:
        return None

    # Link object to the scene collection
    bpy.context.scene.collection.objects.link(obj)

    # Move object to cursor
    obj.location = textobject.location.copy()
    obj.rotation_euler = textobject.rotation_euler.copy()
    obj.scale.x = scaleM / 5
    obj.scale.y = scaleM / 5


    depsgraph = bpy.context.evaluated_depsgraph_get()
    obj_eval = obj.evaluated_get(depsgraph)
    bbox = [Vector(corner) for corner in obj_eval.bound_box]
    icon_xSize = max(v.x for v in bbox) - min(v.x for v in bbox)

    icon_xSize = icon_xSize * obj.scale.x

    depsgraph = bpy.context.evaluated_depsgraph_get()
    obj_eval = textobject.evaluated_get(depsgraph)
    bbox = [Vector(corner) for corner in obj_eval.bound_box]
    text_xSize = max(v.x for v in bbox) - min(v.x for v in bbox)

    text_xSize = text_xSize / obj.scale.x

    obj.location -= obj.matrix_world.to_3x3() @ Vector((text_xSize/2 + 0.5, 0, 0))
    textobject.location += textobject.matrix_world.to_3x3() @ Vector((icon_xSize/2 + 0.5, 0, 0))


    # Make the object active and selected
    bpy.ops.object.select_all(action='DESELECT')
    obj.select_set(True)
    textobject.select_set(True)
    bpy.context.view_layer.objects.active = obj

    return obj

def textIcon(iconString,tobj,MapObject, merge = False, scaleMo = 1):

    icon = None

    if iconString != "no" and iconString != "":
        icon = appendTextIcon(tobj,iconString, scaleMo)
        if merge == True:
            icon.scale.z = 10
            merge_with_map(MapObject, icon)
            icon.location.z += 0.35


    return icon

def replaceShapeText(textfield, textobj):

    total_elevation = bpy.context.scene.tp3d.total_elevation
    total_length = bpy.context.scene.tp3d.total_length
    time_str = bpy.context.scene.tp3d.sTime_str
    average_speed = bpy.context.scene.tp3d.average_speed
    trail_date =  bpy.context.scene.tp3d.trail_date

    if "{length}" in textfield:
        textfield = textfield.replace("{length}", f"{total_length:.2f}km")
        update_text_object(textobj.name, textfield)
    elif "{elevation}" in textfield:
        textfield = textfield.replace("{elevation}", f"{total_elevation:.2f}m")
        update_text_object(textobj.name, textfield)
    elif "{duration}" in textfield:
        textfield = textfield.replace("{duration}", f"{time_str}")
        update_text_object(textobj.name, textfield)
    elif "{date}" in textfield:
        textfield = textfield.replace("{date}", trail_date)
        update_text_object(textobj.name, textfield)
    elif "{speed}" in textfield:
        textfield = textfield.replace("{speed}", f"{average_speed:.2f} km/h")
        update_text_object(textobj.name, textfield)
    elif "{name}" in textfield:
        nm = bpy.context.scene.tp3d.modelname
        print(f"Name: {nm}")
        textfield = textfield.replace("{name}", f"{nm}")
        update_text_object(textobj.name, textfield)
    else:
        update_text_object(textobj.name, textfield)
    
    return textfield

def HexagonInnerText(MapObject):
    
    
    size = bpy.context.scene.tp3d.objSize
    name = bpy.context.scene.tp3d.modelname
    centerx = bpy.context.scene.tp3d.o_centerx
    centery = bpy.context.scene.tp3d.o_centery
    titlefield = bpy.context.scene.tp3d.titlefield
    textfield1 = bpy.context.scene.tp3d.textfield1
    textfield2 = bpy.context.scene.tp3d.textfield2
    textfield3 = bpy.context.scene.tp3d.textfield3
    titleIcon = bpy.context.scene.tp3d.titleIcon
    iconString1 = bpy.context.scene.tp3d.iconText1
    iconString2 = bpy.context.scene.tp3d.iconText2
    iconString3 = bpy.context.scene.tp3d.iconText3
    xTerrainOffset = bpy.context.scene.tp3d.xTerrainOffset
    yTerrainOffset = bpy.context.scene.tp3d.yTerrainOffset
    pathScale = bpy.context.scene.tp3d.pathScale

    textSize = bpy.context.scene.tp3d.textSize
    textSize2 = bpy.context.scene.tp3d.textSizeTitle
    shapeRotation = bpy.context.scene.tp3d.shapeRotation

    if textSize2 == 0:
        textSize2 = textSize
    

    #dist =  (size/2 - size/2 * (1-pathScale)/2)
    dist =  (size/2 - size/2 * (1-0.8)/2)
    
    temp_y = math.sin(math.radians(90)) * (dist  * math.cos(math.radians(30)))
    

    
    tName = create_text("t_name", "Name", (0, temp_y, 0.1),1)

    for i, (text_name, angle) in enumerate(zip(["t_length", "t_elevation", "t_duration"], [210, 270, 330])):
        angle_centered = angle + 90
        x = math.cos(math.radians(angle)) * (dist * math.cos(math.radians(30)))
        y = math.sin(math.radians(angle)) * (dist * math.cos(math.radians(30)))
        rot_z = math.radians(angle_centered)
        create_text(text_name, text_name.split("_")[1].capitalize(), (x, y, 0.1),1,  (0, 0, rot_z), 100)
    
    tElevation = bpy.data.objects.get("t_elevation")
    tLength = bpy.data.objects.get("t_length")
    tDuration = bpy.data.objects.get("t_duration")

    

    
    transform_MapObject(tName, centerx + xTerrainOffset, centery + yTerrainOffset)
    transform_MapObject(tElevation, centerx + xTerrainOffset, centery + yTerrainOffset)
    transform_MapObject(tLength, centerx + xTerrainOffset, centery + yTerrainOffset)
    transform_MapObject(tDuration,centerx + xTerrainOffset, centery + yTerrainOffset)
    
    #Scale text sizes to mm values (blender units)
    bpy.context.view_layer.update()
    current_height = tName.dimensions.y
    if current_height == 0:
        current_height = tElevation.dimensions.y
    if current_height == 0:
        current_height = tLength.dimensions.y
    if current_height == 0:
        current_height = 5
    scale_factor_title = textSize2 / current_height
    tName.scale.x *= scale_factor_title
    tName.scale.y *= scale_factor_title

    scale_factor = textSize / current_height
    tElevation.scale.x *= scale_factor
    tLength.scale.x *= scale_factor
    tDuration.scale.x *= scale_factor
    tElevation.scale.y *= scale_factor
    tLength.scale.y *= scale_factor
    tDuration.scale.y *= scale_factor

    bpy.ops.object.select_all(action='DESELECT')

    tName.select_set(True)
    tElevation.select_set(True)
    tLength.select_set(True)
    tDuration.select_set(True)
    bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)

    titlefield = replaceShapeText(titlefield, tName)
    textfield1 = replaceShapeText(textfield1, tLength)
    textfield2 = replaceShapeText(textfield2, tElevation)
    textfield3 = replaceShapeText(textfield3, tDuration)
    
    icon0 = None
    icon1 = None
    icon2 = None
    icon3 = None


    icon0 = textIcon(titleIcon,tName,MapObject,False, textSize2 )
    icon1 = textIcon(iconString1,tLength,MapObject,False, textSize)
    icon2 = textIcon(iconString2,tElevation,MapObject,False,textSize)
    icon3 = textIcon(iconString3,tDuration,MapObject,False,textSize)

    #_progress.ProgressOverlay.get().finish()
    #raise Exception("debug stop")

    projection("separate",MapObject,tName)
    projection("separate",MapObject,tLength)
    projection("separate",MapObject,tElevation)
    projection("separate",MapObject,tDuration)

    for _icon in (icon0, icon1, icon2, icon3):
        if _icon is None:
            continue
        bpy.ops.object.select_all(action='DESELECT')
        _icon.select_set(True)
        bpy.context.view_layer.objects.active = _icon
        bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY', center='MEDIAN')

        # Delete bottom faces by z-position instead of face-normal direction.
        # Normal-based selection (selectBottomFaces threshold -0.95) fails when
        # recalc_normals flips the bottom copy upward for taller icons (high minThickness).
        bm = bmesh.new()
        bm.from_mesh(_icon.data)
        if bm.verts:
            min_z = min(v.co.z for v in bm.verts)
            faces_to_del = [f for f in bm.faces if f.calc_center_median().z < (min_z + 0.3)]
            bmesh.ops.delete(bm, geom=faces_to_del, context='FACES')
            bm.to_mesh(_icon.data)
        bm.free()



    projection("separate", MapObject, icon0)
    projection("separate", MapObject, icon1)
    projection("separate", MapObject, icon2)
    projection("separate", MapObject, icon3)
    

    bpy.ops.object.select_all(action='DESELECT')

    if icon0 != None: icon0.select_set(True)
    if icon1 != None: icon1.select_set(True)
    if icon2 != None: icon2.select_set(True)
    if icon3 != None: icon3.select_set(True)


    tName.select_set(True)
    tElevation.select_set(True)
    tLength.select_set(True)
    tDuration.select_set(True)
    #curveObj.select_set(True)
    

    bpy.context.view_layer.objects.active = tName
    
    bpy.ops.object.join()
    bpy.ops.object.origin_set(type='ORIGIN_CURSOR', center='MEDIAN')

    tName.name = name + "_Text"
    tName.rotation_euler[2] += shapeRotation * (3.14159265 / 180)

    tName.select_set(True)
    bpy.context.view_layer.objects.active = tName
    bpy.ops.object.transform_apply(location = False, rotation=True, scale = False)
    bpy.ops.object.origin_set(type='ORIGIN_CURSOR', center='MEDIAN')


    
    textobj = tName
    return textobj
    
def _apply_plate_bevel(obj, bevel_amount, thickness):
    """Bevel the top and bottom perimeter edges of a plate object."""
    if bevel_amount <= 0:
        return
    bm = bmesh.new()
    bm.from_mesh(obj.data)
    bm.verts.ensure_lookup_table()
    bm.edges.ensure_lookup_table()
    bevel_edges = []
    for edge in bm.edges:
        v0_z = edge.verts[0].co.z
        v1_z = edge.verts[1].co.z
        same_top = abs(v0_z) < 0.01 and abs(v1_z) < 0.01
        same_bottom = abs(v0_z + thickness) < 0.01 and abs(v1_z + thickness) < 0.01
        if same_top or same_bottom:
            for face in edge.link_faces:
                face_z_vals = [v.co.z for v in face.verts]
                if min(face_z_vals) < -0.01 and max(face_z_vals) > -0.01:
                    bevel_edges.append(edge)
                    break
    if bevel_edges:
        bmesh.ops.bevel(bm, geom=bevel_edges, offset=bevel_amount, segments=1, affect='EDGES', profile = 0.5)
        bm.to_mesh(obj.data)
    bm.free()
    obj.data.update()


def HexagonOuterText():

    size = bpy.context.scene.tp3d.objSize
    outerBorderSize = bpy.context.scene.tp3d.outerBorderSize
    plateThickness = bpy.context.scene.tp3d.plateThickness
    name = bpy.context.scene.tp3d.modelname
    centerx = bpy.context.scene.tp3d.o_centerx
    centery = bpy.context.scene.tp3d.o_centery
    text_angle_preset = bpy.context.scene.tp3d.text_angle_preset
    titlefield = bpy.context.scene.tp3d.titlefield
    textfield1 = bpy.context.scene.tp3d.textfield1
    textfield2 = bpy.context.scene.tp3d.textfield2
    textfield3 = bpy.context.scene.tp3d.textfield3
    titleIcon = bpy.context.scene.tp3d.titleIcon
    iconString1 = bpy.context.scene.tp3d.iconText1
    iconString2 = bpy.context.scene.tp3d.iconText2
    iconString3 = bpy.context.scene.tp3d.iconText3
    
    
    outersize = size * ( 1 + outerBorderSize/100)
    thickness = plateThickness
    textSize = bpy.context.scene.tp3d.textSize
    textSize2 = bpy.context.scene.tp3d.textSizeTitle
    shapeRotation = bpy.context.scene.tp3d.shapeRotation

    if textSize2 == 0:
        textSize2 = textSize
    
    
    verts = []
    faces = []
    for i in range(6):
        angle = math.radians(60 * i)
        x = outersize/2 * math.cos(angle)
        y = outersize/2 * math.sin(angle)
        verts.append((x, y, 0))
    verts.append((0, 0, 0))  # Center vertex
    faces = [[i, (i + 1) % 6, 6] for i in range(6)]
    mesh = bpy.data.meshes.new("HexagonOuter")
    outerHex = bpy.data.objects.new("HexagonOuter", mesh)
    bpy.context.collection.objects.link(outerHex)
    mesh.from_pydata(verts, [], faces)
    mesh.update()
    outerHex.name = name
    outerHex.data.name = name
    
    bpy.context.view_layer.objects.active = outerHex
    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.mesh.extrude_region_move()
    bpy.ops.transform.translate(value=(0, 0, -8))#bpy.ops.mesh.select_all(action='DESELECT')

    bpy.ops.object.mode_set(mode='OBJECT')

    # Get the mesh data
    mesh = outerHex.data

    # Get selected faces
    selected_faces = [face for face in mesh.polygons if face.select]
    
    if selected_faces:
        for face in selected_faces:
            for vert_idx in face.vertices:
                vert = mesh.vertices[vert_idx]
                vert.co.z =  - thickness
    else:
        print("No face selected.")

    _apply_plate_bevel(outerHex, bpy.context.scene.tp3d.plateBevel, thickness)

    transform_MapObject(outerHex, centerx, centery)


    dist = (outersize - size)/4 + size/2
    
    


    for i, (text_name, angle) in enumerate(zip(["t_name","t_length", "t_elevation", "t_duration"], [90 + text_angle_preset, 210 + text_angle_preset, 270 + text_angle_preset, 330 + text_angle_preset])):
        angle_centered = angle + 90
        x = math.cos(math.radians(angle)) * (dist * math.cos(math.radians(30)))
        y = math.sin(math.radians(angle)) * (dist * math.cos(math.radians(30)))
        rot_z = math.radians(angle_centered)
        if i == 0:
            rot_z += math.radians(180)
        create_text(text_name, text_name.split("_")[1].capitalize(), (x, y,1.4),1,  (0, 0, rot_z), 0.4)
    
    tName = bpy.data.objects.get("t_name")
    tElevation = bpy.data.objects.get("t_elevation")
    tLength = bpy.data.objects.get("t_length")
    tDuration = bpy.data.objects.get("t_duration")

    
    
    transform_MapObject(tName, centerx, centery)
    transform_MapObject(tElevation, centerx, centery)
    transform_MapObject(tLength, centerx, centery)
    transform_MapObject(tDuration, centerx, centery)
    

    #Scale text sizes to mm values (blender units)
    bpy.context.view_layer.update()
    current_height = tName.dimensions.y
    if current_height == 0:
        current_height = tElevation.dimensions.y
    if current_height == 0:
        current_height = tLength.dimensions.y
    if current_height == 0:
        current_height = 5
    scale_factor_title = textSize2 / current_height
    tName.scale.x *= scale_factor_title
    tName.scale.y *= scale_factor_title

    scale_factor = textSize / current_height
    tElevation.scale.x *= scale_factor
    tLength.scale.x *= scale_factor
    tDuration.scale.x *= scale_factor
    tElevation.scale.y *= scale_factor
    tLength.scale.y *= scale_factor
    tDuration.scale.y *= scale_factor

    bpy.ops.object.select_all(action='DESELECT')

    tName.select_set(True)
    tElevation.select_set(True)
    tLength.select_set(True)
    tDuration.select_set(True)

    bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)


    titlefield = replaceShapeText(titlefield, tName)
    textfield1 = replaceShapeText(textfield1, tLength)
    textfield2 = replaceShapeText(textfield2, tElevation)
    textfield3 = replaceShapeText(textfield3, tDuration)
    
    icon0 = None
    icon1 = None
    icon2 = None
    icon3 = None


    icon0 = textIcon(titleIcon,tName,outerHex, False, textSize2)
    icon1 = textIcon(iconString1,tLength,outerHex, False, textSize)
    icon2 = textIcon(iconString2,tElevation,outerHex, False, textSize)
    icon3 = textIcon(iconString3,tDuration,outerHex, False, textSize)


    convert_text_to_mesh("t_name", outerHex.name, False)
    convert_text_to_mesh("t_elevation", outerHex.name, False)
    convert_text_to_mesh("t_length", outerHex.name, False)
    convert_text_to_mesh("t_duration", outerHex.name, False)

    

    bpy.ops.object.select_all(action='DESELECT')

    if icon0 != None: icon0.select_set(True)
    if icon1 != None: icon1.select_set(True)
    if icon2 != None: icon2.select_set(True)
    if icon3 != None: icon3.select_set(True)

    bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)

    
    tName.select_set(True)
    tElevation.select_set(True)
    tLength.select_set(True)
    tDuration.select_set(True)

    
    bpy.context.view_layer.objects.active = tName

    
    bpy.ops.object.join()

    bpy.ops.object.origin_set(type='ORIGIN_CURSOR', center='MEDIAN')

    tName.name = name + "_Text"
    outerHex.name = name + "_Plate"

    tName.location.z += plateThickness
    outerHex.location.z += plateThickness


    #SHAPE ROTATION
    outerHex.rotation_euler[2] += shapeRotation * (3.14159265 / 180)
    outerHex.select_set(True)
    bpy.context.view_layer.objects.active = outerHex
    bpy.ops.object.transform_apply(location = False, rotation=True, scale = False)

    bpy.ops.object.origin_set(type='ORIGIN_CURSOR', center='MEDIAN')


    plateobj = outerHex

    textobj = tName
    return textobj, plateobj


def HexagonFrontText():

    size = bpy.context.scene.tp3d.objSize
    outerBorderSize = bpy.context.scene.tp3d.outerBorderSize
    plateThickness = bpy.context.scene.tp3d.plateThickness
    name = bpy.context.scene.tp3d.modelname
    centerx = bpy.context.scene.tp3d.o_centerx
    centery = bpy.context.scene.tp3d.o_centery
    text_angle_preset = bpy.context.scene.tp3d.text_angle_preset
    titlefield = bpy.context.scene.tp3d.titlefield
    textfield1 = bpy.context.scene.tp3d.textfield1
    textfield2 = bpy.context.scene.tp3d.textfield2
    textfield3 = bpy.context.scene.tp3d.textfield3
    titleIcon = bpy.context.scene.tp3d.titleIcon
    iconString1 = bpy.context.scene.tp3d.iconText1
    iconString2 = bpy.context.scene.tp3d.iconText2
    iconString3 = bpy.context.scene.tp3d.iconText3
    minThickness = bpy.context.scene.tp3d.minThickness
    
    outersize = size * ( 1 + outerBorderSize/100)
    thickness = plateThickness
    textSize = bpy.context.scene.tp3d.textSize
    textSize2 = bpy.context.scene.tp3d.textSizeTitle
    shapeRotation = bpy.context.scene.tp3d.shapeRotation
    
    

    if textSize2 == 0:
        textSize2 = textSize
    
    
    verts = []
    faces = []
    for i in range(6):
        angle = math.radians(60 * i)
        x = outersize/2 * math.cos(angle)
        y = outersize/2 * math.sin(angle)
        verts.append((x, y, 0))
    verts.append((0, 0, 0))  # Center vertex
    faces = [[i, (i + 1) % 6, 6] for i in range(6)]
    mesh = bpy.data.meshes.new("HexagonOuter")
    outerHex = bpy.data.objects.new("HexagonOuter", mesh)
    bpy.context.collection.objects.link(outerHex)
    mesh.from_pydata(verts, [], faces)
    mesh.update()
    outerHex.name = name
    outerHex.data.name = name
    
    bpy.context.view_layer.objects.active = outerHex
    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.mesh.extrude_region_move()
    bpy.ops.transform.translate(value=(0, 0, -8))#bpy.ops.mesh.select_all(action='DESELECT')

    bpy.ops.object.mode_set(mode='OBJECT')

    # Get the mesh data
    mesh = outerHex.data

    # Get selected faces
    selected_faces = [face for face in mesh.polygons if face.select]
    
    if selected_faces:
        for face in selected_faces:
            for vert_idx in face.vertices:
                vert = mesh.vertices[vert_idx]
                vert.co.z =  - thickness;
    else:
        print("No face selected.")

    _apply_plate_bevel(outerHex, bpy.context.scene.tp3d.plateBevel, thickness)

    transform_MapObject(outerHex, centerx, centery)

    dist = outersize/2
    
    temp_y = math.sin(math.radians(90)) * (dist  * math.cos(math.radians(30)))
    
    

    for i, (text_name, angle) in enumerate(zip(["t_name","t_length", "t_elevation", "t_duration"], [90 + text_angle_preset, 210 + text_angle_preset, 270 + text_angle_preset, 330 + text_angle_preset])):
        angle_centered = angle + 90
        x = math.cos(math.radians(angle)) * (dist * math.cos(math.radians(30)))
        y = math.sin(math.radians(angle)) * (dist * math.cos(math.radians(30)))
        rot_z = math.radians(angle_centered)
        #if i == 0:
            #rot_z += math.radians(180)
        create_text(text_name, text_name.split("_")[1].capitalize(), (x, y,minThickness/2 - plateThickness / 2),1,  (math.radians(90), 0, rot_z), 0.4)
    
    tName = bpy.data.objects.get("t_name")
    tElevation = bpy.data.objects.get("t_elevation")
    tLength = bpy.data.objects.get("t_length")
    tDuration = bpy.data.objects.get("t_duration")
    
    
    transform_MapObject(tName, centerx, centery)
    transform_MapObject(tElevation, centerx, centery)
    transform_MapObject(tLength, centerx, centery)
    transform_MapObject(tDuration, centerx, centery)
    
    #Scale text sizes to mm values (blender units)
    bpy.context.view_layer.update()
    current_height = tName.dimensions.y
    if current_height == 0:
        current_height = tElevation.dimensions.y
    if current_height == 0:
        current_height = tLength.dimensions.y
    if current_height == 0:
        current_height = 5
    scale_factor = textSize2 / current_height
    tName.scale.x *= scale_factor
    tName.scale.y *= scale_factor

    scale_factor = textSize / current_height
    tElevation.scale.x *= scale_factor
    tLength.scale.x *= scale_factor
    tDuration.scale.x *= scale_factor
    tElevation.scale.y *= scale_factor
    tLength.scale.y *= scale_factor
    tDuration.scale.y *= scale_factor


    bpy.ops.object.select_all(action='DESELECT')
    
    tName.select_set(True)
    tElevation.select_set(True)
    tLength.select_set(True)
    tDuration.select_set(True)

    bpy.ops.object.transform_apply(location = False, rotation=False, scale = True)



    titlefield = replaceShapeText(titlefield, tName)
    textfield1 = replaceShapeText(textfield1, tLength)
    textfield2 = replaceShapeText(textfield2, tElevation)
    textfield3 = replaceShapeText(textfield3, tDuration)
    
    icon0 = None
    icon1 = None
    icon2 = None
    icon3 = None

    icon0 = textIcon(titleIcon,tName,outerHex, False, textSize2)
    icon1 = textIcon(iconString1,tLength,outerHex, False, textSize)
    icon2 = textIcon(iconString2,tElevation,outerHex, False, textSize)
    icon3 = textIcon(iconString3,tDuration,outerHex, False, textSize)

    convert_text_to_mesh("t_name", outerHex.name, False)
    convert_text_to_mesh("t_elevation", outerHex.name, False)
    convert_text_to_mesh("t_length", outerHex.name, False)
    convert_text_to_mesh("t_duration", outerHex.name, False)
    


    bpy.ops.object.select_all(action='DESELECT')

    if icon0 != None: icon0.select_set(True)
    if icon1 != None: icon1.select_set(True)
    if icon2 != None: icon2.select_set(True)
    if icon3 != None: icon3.select_set(True)
    
    tName.select_set(True)
    tElevation.select_set(True)
    tLength.select_set(True)
    tDuration.select_set(True)

    bpy.context.view_layer.objects.active = tName

    bpy.ops.object.join()

    bpy.ops.object.origin_set(type='ORIGIN_CURSOR', center='MEDIAN')

    tName.name = name + "_Text"
    outerHex.name = name + "_Plate"

    tName.location.z += plateThickness
    outerHex.location.z += plateThickness

    #SHAPE ROTATION
    outerHex.rotation_euler[2] += shapeRotation * (3.14159265 / 180)
    outerHex.select_set(True)
    bpy.context.view_layer.objects.active = outerHex
    bpy.ops.object.transform_apply(location = False, rotation=True, scale = False)
    bpy.ops.object.origin_set(type='ORIGIN_CURSOR', center='MEDIAN')


    plateobj = outerHex

    textobj = tName

    return textobj, plateobj

def OctagonOuterText():

    size = bpy.context.scene.tp3d.objSize
    outerBorderSize = bpy.context.scene.tp3d.outerBorderSize
    plateThickness = bpy.context.scene.tp3d.plateThickness
    name = bpy.context.scene.tp3d.modelname
    centerx = bpy.context.scene.tp3d.o_centerx
    centery = bpy.context.scene.tp3d.o_centery
    text_angle_preset = bpy.context.scene.tp3d.text_angle_preset
    titlefield = bpy.context.scene.tp3d.titlefield
    textfield1 = bpy.context.scene.tp3d.textfield1
    textfield2 = bpy.context.scene.tp3d.textfield2
    textfield3 = bpy.context.scene.tp3d.textfield3
    titleIcon = bpy.context.scene.tp3d.titleIcon
    iconString1 = bpy.context.scene.tp3d.iconText1
    iconString2 = bpy.context.scene.tp3d.iconText2
    iconString3 = bpy.context.scene.tp3d.iconText3


    num_sides = 8
    outersize = size * (1 + outerBorderSize / 100)
    thickness = plateThickness
    textSize = bpy.context.scene.tp3d.textSize
    textSize2 = bpy.context.scene.tp3d.textSizeTitle
    shapeRotation = bpy.context.scene.tp3d.shapeRotation

    if textSize2 == 0:
        textSize2 = textSize

    verts = []
    faces = []

    # Create vertices for octagon
    for i in range(num_sides):
        angle = math.radians(360 / num_sides * i + 22.5)
        x = outersize / 2 * math.cos(angle)
        y = outersize / 2 * math.sin(angle)
        verts.append((x, y, 0))
    verts.append((0, 0, 0))  # center vertex
    faces = [[i, (i + 1) % num_sides, num_sides] for i in range(num_sides)]

    mesh = bpy.data.meshes.new("OctagonOuter")
    outerOct = bpy.data.objects.new("OctagonOuter", mesh)
    bpy.context.collection.objects.link(outerOct)
    mesh.from_pydata(verts, [], faces)
    mesh.update()
    outerOct.name = name
    outerOct.data.name = name

    bpy.context.view_layer.objects.active = outerOct
    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.mesh.extrude_region_move()
    bpy.ops.transform.translate(value=(0, 0, -8))
    bpy.ops.object.mode_set(mode='OBJECT')

    mesh = outerOct.data
    selected_faces = [face for face in mesh.polygons if face.select]

    if selected_faces:
        for face in selected_faces:
            for vert_idx in face.vertices:
                vert = mesh.vertices[vert_idx]
                vert.co.z = -thickness
    else:
        print("No face selected.")

    _apply_plate_bevel(outerOct, bpy.context.scene.tp3d.plateBevel, thickness)

    transform_MapObject(outerOct, centerx, centery)

    #Text placement
    dist = (outersize - size) / 4 + size / 2
    text_labels = ["t_name", "t_length", "t_elevation", "t_duration"]

    # Choose 4 corners of the octagon
    base_angles = [90 + text_angle_preset, 225 + text_angle_preset, 270 + text_angle_preset, 315 + text_angle_preset]

    for i, (text_name, angle) in enumerate(zip(text_labels, base_angles)):
        angle_centered = angle + 90
        x = math.cos(math.radians(angle)) * (dist * math.cos(math.radians(22.5)))
        y = math.sin(math.radians(angle)) * (dist * math.cos(math.radians(22.5)))
        rot_z = math.radians(angle_centered)
        if i == 0:
            rot_z += math.radians(180)
        create_text(text_name, text_name.split("_")[1].capitalize(), (x, y,1.4),1,  (0, 0, rot_z), 0.4)



    # Get text objects
    tName = bpy.data.objects.get("t_name")
    tElevation = bpy.data.objects.get("t_elevation")
    tLength = bpy.data.objects.get("t_length")
    tDuration = bpy.data.objects.get("t_duration")

    # Position relative to plate
    transform_MapObject(tName, centerx, centery)
    transform_MapObject(tElevation, centerx, centery)
    transform_MapObject(tLength, centerx, centery)
    transform_MapObject(tDuration, centerx, centery)
    
    #Scale text sizes to mm values (blender units)
    bpy.context.view_layer.update()
    current_height = tName.dimensions.y
    if current_height == 0:
        current_height = tElevation.dimensions.y
    if current_height == 0:
        current_height = tLength.dimensions.y
    if current_height == 0:
        current_height = 5
    scale_factor = textSize2 / current_height
    tName.scale.x *= scale_factor
    tName.scale.y *= scale_factor

    scale_factor = textSize / current_height
    tElevation.scale.x *= scale_factor
    tLength.scale.x *= scale_factor
    tDuration.scale.x *= scale_factor
    tElevation.scale.y *= scale_factor
    tLength.scale.y *= scale_factor
    tDuration.scale.y *= scale_factor

    bpy.ops.object.select_all(action='DESELECT')

    tName.select_set(True)
    tElevation.select_set(True)
    tLength.select_set(True)
    tDuration.select_set(True)

    bpy.ops.object.transform_apply(location = False, rotation=False, scale = True)

    titlefield = replaceShapeText(titlefield, tName)
    textfield1 = replaceShapeText(textfield1, tLength)
    textfield2 = replaceShapeText(textfield2, tElevation)
    textfield3 = replaceShapeText(textfield3, tDuration)
    
    icon0 = None
    icon1 = None
    icon2 = None
    icon3 = None

    icon0 = textIcon(titleIcon,tName,outerOct, False, textSize2)
    icon1 = textIcon(iconString1,tLength,outerOct, False, textSize)
    icon2 = textIcon(iconString2,tElevation,outerOct, False, textSize)
    icon3 = textIcon(iconString3,tDuration,outerOct, False, textSize)

    convert_text_to_mesh("t_name", outerOct.name, False)
    convert_text_to_mesh("t_elevation", outerOct.name, False)
    convert_text_to_mesh("t_length", outerOct.name, False)
    convert_text_to_mesh("t_duration", outerOct.name, False)
    

    bpy.ops.object.select_all(action='DESELECT')

    if icon0 != None: icon0.select_set(True)
    if icon1 != None: icon1.select_set(True)
    if icon2 != None: icon2.select_set(True)
    if icon3 != None: icon3.select_set(True)







    tName.select_set(True)
    tElevation.select_set(True)
    tLength.select_set(True)
    tDuration.select_set(True)
    bpy.context.view_layer.objects.active = tName
    bpy.ops.object.join()
    bpy.ops.object.origin_set(type='ORIGIN_CURSOR', center='MEDIAN')

    tName.name = name + "_Text"
    outerOct.name = name + "_Plate"

    tName.location.z += plateThickness
    outerOct.location.z += plateThickness


    #SHAPE ROTATION
    outerOct.rotation_euler[2] += shapeRotation * (3.14159265 / 180)
    outerOct.select_set(True)
    bpy.context.view_layer.objects.active = outerOct
    bpy.ops.object.transform_apply(location = False, rotation=True, scale = False)
    bpy.ops.object.origin_set(type='ORIGIN_CURSOR', center='MEDIAN')


    plateobj = outerOct

    textobj = tName

    return textobj, plateobj
    
def MedalText():

    size = bpy.context.scene.tp3d.objSize
    outerBorderSize = bpy.context.scene.tp3d.outerBorderSize
    plateThickness = bpy.context.scene.tp3d.plateThickness
    name = bpy.context.scene.tp3d.modelname
    centerx = bpy.context.scene.tp3d.o_centerx
    centery = bpy.context.scene.tp3d.o_centery
    text_angle_preset = bpy.context.scene.tp3d.text_angle_preset
    titlefield = bpy.context.scene.tp3d.titlefield
    textfield1 = bpy.context.scene.tp3d.textfield1
    textfield2 = bpy.context.scene.tp3d.textfield2
    textfield3 = bpy.context.scene.tp3d.textfield3
    titleIcon = bpy.context.scene.tp3d.titleIcon
    iconString1 = bpy.context.scene.tp3d.iconText1
    iconString2 = bpy.context.scene.tp3d.iconText2
    iconString3 = bpy.context.scene.tp3d.iconText3

    outersize = size * (1 + outerBorderSize / 100)
    thickness = plateThickness
    textSize = bpy.context.scene.tp3d.textSize
    textSize2 = bpy.context.scene.tp3d.textSizeTitle
    shapeRotation = bpy.context.scene.tp3d.shapeRotation

    if textSize2 == 0:
        textSize2 = textSize

    # --- Plate circle (slightly bigger, same center as coin, behind it in Z) ---
    plate_radius = outersize / 2
    num_segments = 64

    verts = []
    for i in range(num_segments):
        angle = 2 * math.pi * i / num_segments
        x = plate_radius * math.cos(angle)
        y = plate_radius * math.sin(angle)
        verts.append((x, y, 0))

    edges = [(i, (i + 1) % num_segments) for i in range(num_segments)]
    plate_mesh_data = bpy.data.meshes.new("MedalPlate")
    plateObj = bpy.data.objects.new("MedalPlate", plate_mesh_data)
    bpy.context.collection.objects.link(plateObj)
    plate_mesh_data.from_pydata(verts, edges, [])
    plate_mesh_data.update()

    bpy.context.view_layer.objects.active = plateObj
    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.mesh.fill()
    bpy.ops.mesh.extrude_region_move()
    bpy.ops.transform.translate(value=(0, 0, -8))
    bpy.ops.object.mode_set(mode='OBJECT')

    plate_mesh_data = plateObj.data
    selected_faces = [face for face in plate_mesh_data.polygons if face.select]
    if selected_faces:
        for face in selected_faces:
            for vert_idx in face.vertices:
                vert = plate_mesh_data.vertices[vert_idx]
                vert.co.z = -thickness
    else:
        print("No face selected.")

    _apply_plate_bevel(plateObj, bpy.context.scene.tp3d.plateBevel, thickness)

    plateObj.name = name
    plateObj.data.name = name
    transform_MapObject(plateObj, centerx, centery)

    # --- Curved text in the ring between coin edge and plate edge ---
    # Text sits at the midpoint of the ring so it fits in the open space the map doesn't cover.
    text_radius = (size / 2 + outersize / 2) / 2

    # Create ONE bezier circle that all text objects will follow.
    # Place it at (centerx, centery, 0.4) — the same Z that create_text ends up at
    # (create_text receives z=1.4 and does location.z -= 1 internally → z = 0.4).
    bpy.ops.curve.primitive_bezier_circle_add(
        radius=text_radius, location=(centerx, centery, 0.4)
    )
    circle_path = bpy.context.active_object
    circle_path.name = name + "_TextCircle"

    # Switch to clockwise so the title at the top reads left-to-right when viewed from +Z.
    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.curve.switch_direction()
    bpy.ops.object.mode_set(mode='OBJECT')

    # Angles: title at top (90°), other three distributed around the lower arc.
    text_angles = [
        90  + text_angle_preset,
        210 + text_angle_preset,
        270 + text_angle_preset,
        330 + text_angle_preset,
    ]

    for text_name, angle in zip(
        ["t_name", "t_length", "t_elevation", "t_duration"],
        text_angles
    ):
        # For the CW circle (start = 3-o'clock, going clockwise):
        # to reach the point at angle θ (CCW from right), travel CW by (360 − θ)°.
        arc_offset = text_radius * math.radians(360 - angle % 360)

        # create_text positions at (x, y, 1.4) and does z -= 1 → final z = 0.4.
        # We already include centerx/centery in x/y so transform_MapObject is NOT called.
        txt_obj = create_text(
            text_name,
            text_name.split("_")[1].capitalize(),
            (arc_offset + centerx, centery, 1.4),
            1,
            (0, 0, 0),
            0.4,
        )
        txt_obj.data.follow_curve = circle_path

    tName      = bpy.data.objects.get("t_name")
    tElevation = bpy.data.objects.get("t_elevation")
    tLength    = bpy.data.objects.get("t_length")
    tDuration  = bpy.data.objects.get("t_duration")

    # Scale text to physical mm values
    bpy.context.view_layer.update()
    current_height = tName.dimensions.y
    if current_height == 0:
        current_height = tElevation.dimensions.y
    if current_height == 0:
        current_height = tLength.dimensions.y
    if current_height == 0:
        current_height = 5

    scale_factor_title = textSize2 / current_height
    tName.scale.x *= scale_factor_title
    tName.scale.y *= scale_factor_title

    scale_factor = textSize / current_height
    tElevation.scale.x *= scale_factor
    tLength.scale.x    *= scale_factor
    tDuration.scale.x  *= scale_factor
    tElevation.scale.y *= scale_factor
    tLength.scale.y    *= scale_factor
    tDuration.scale.y  *= scale_factor

    bpy.ops.object.select_all(action='DESELECT')
    tName.select_set(True)
    tElevation.select_set(True)
    tLength.select_set(True)
    tDuration.select_set(True)
    bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)

    titlefield  = replaceShapeText(titlefield,  tName)
    textfield1  = replaceShapeText(textfield1,  tLength)
    textfield2  = replaceShapeText(textfield2,  tElevation)
    textfield3  = replaceShapeText(textfield3,  tDuration)

    icon0 = textIcon(titleIcon,   tName,      plateObj, False, textSize2)
    icon1 = textIcon(iconString1, tLength,    plateObj, False, textSize)
    icon2 = textIcon(iconString2, tElevation, plateObj, False, textSize)
    icon3 = textIcon(iconString3, tDuration,  plateObj, False, textSize)

    convert_text_to_mesh("t_name",      plateObj.name, False)
    convert_text_to_mesh("t_elevation", plateObj.name, False)
    convert_text_to_mesh("t_length",    plateObj.name, False)
    convert_text_to_mesh("t_duration",  plateObj.name, False)

    # Remove the helper bezier circle — follow_curve is now baked into the meshes.
    bpy.ops.object.select_all(action='DESELECT')
    if circle_path.name in bpy.data.objects:
        bpy.data.objects.remove(circle_path, do_unlink=True)

    bpy.ops.object.select_all(action='DESELECT')
    if icon0 is not None: icon0.select_set(True)
    if icon1 is not None: icon1.select_set(True)
    if icon2 is not None: icon2.select_set(True)
    if icon3 is not None: icon3.select_set(True)

    tName.select_set(True)
    tElevation.select_set(True)
    tLength.select_set(True)
    tDuration.select_set(True)
    bpy.context.view_layer.objects.active = tName
    bpy.ops.object.join()
    bpy.ops.object.origin_set(type='ORIGIN_CURSOR', center='MEDIAN')

    tName.name    = name + "_Text"
    plateObj.name = name + "_Plate"

    tName.location.z    += plateThickness
    plateObj.location.z += plateThickness

    # Shape rotation applied to plate
    plateObj.rotation_euler[2] += shapeRotation * (3.14159265 / 180)
    plateObj.select_set(True)
    bpy.context.view_layer.objects.active = plateObj
    bpy.ops.object.transform_apply(location=False, rotation=True, scale=False)
    bpy.ops.object.origin_set(type='ORIGIN_CURSOR', center='MEDIAN')

    return tName, plateObj


def BottomText(obj):

    pathScale = bpy.context.scene.tp3d.pathScale


    name = obj.name
    if "objSize" in obj:
        size = obj["objSize"]
    else:
        return
    
        # Place text objects
    text_size = (size / 10)
    
    
    
    tName = create_text("t_name", "Name", (0, 0,1.1),text_size)
    

    cx = obj.location.x
    cy = obj.location.y
    
    transform_MapObject(tName, cx, cy)
    
    tName.location.z = obj.location.z + 0.1
    tName.data.extrude = 0.1
    
    tName.scale.x *= -1

    
    update_text_object("t_name", name)
    
    convert_text_to_mesh("t_name", obj.name, False)
    
    tName.name = name + "_Mark"
    
    bpy.ops.object.select_all(action='DESELECT')

    tName.select_set(True)
    
    bpy.context.view_layer.objects.active = tName

    mat = bpy.data.materials.get("TRAIL")
    tName.data.materials.clear()
    tName.data.materials.append(mat)

    return tName
    

def convert_text_to_mesh(text_obj_name, mesh_obj_name, merge = True):
    # Get the text and mesh objects
    text_obj = bpy.data.objects.get(text_obj_name)
    mesh_obj = bpy.data.objects.get(mesh_obj_name)
    
    if not text_obj or not mesh_obj:
        print("One or both objects not found")
        return
    
    # Ensure the text object is selected and active
    bpy.ops.object.select_all(action='DESELECT')
    text_obj.select_set(True)
    bpy.context.view_layer.objects.active = text_obj
    
    # Convert text to mesh
    bpy.ops.object.convert(target='MESH')
    
    # Enter edit mode
    bpy.ops.object.mode_set(mode='EDIT')
    
    # Enable auto-merge vertices
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.mesh.remove_doubles(threshold=0.002)
    #bpy.context.tool_settings.use_mesh_automerge = True
    
    # Switch back to object mode to move it
    bpy.ops.object.mode_set(mode='OBJECT')

    recalculateNormals(text_obj)
    
    # Move the text object up by 1
    text_obj.location.z += 1
    
    # Move the text object down by 1 (merging overlapping vertices)
    text_obj.location.z -= 1
    
    # Disable auto-merge vertices
    bpy.context.tool_settings.use_mesh_automerge = False
    
    if merge == True:
        # Add boolean modifier
        bool_mod = text_obj.modifiers.new(name="Boolean", type='BOOLEAN')
        bool_mod.object = mesh_obj
        bool_mod.operation = 'INTERSECT'
        bool_mod.solver = 'MANIFOLD'

        
        # Apply the boolean modifier
        bpy.ops.object.select_all(action='DESELECT')
        text_obj.select_set(True)
        bpy.context.view_layer.objects.active = text_obj
        bpy.ops.object.modifier_apply(modifier=bool_mod.name)
    
        # Move the text object up by 1
        text_obj.location.z += 0.4
    
def intersectWithTile(tile, element, extrude_amount=1.0):
#'Intersects Element with Tile in x and y so the element fits on the tile shape'

    try:
        # Validate input objects

        if tile.type != 'MESH':
            raise ValueError(f"Tile object '{tile.name}' is not a mesh (type={tile.type}).")

        if element.type != 'MESH':
            print("Obj is not a mesh")
            raise ValueError(f"Element object '{element.name}' is not a mesh (type={element.type}).")

        # Remember current mode and active object so we can restore later
        prev_mode = bpy.context.mode
        prev_active = bpy.context.view_layer.objects.active

        # Duplicate the tile (object + mesh data copy)
        dup = tile.copy()
        dup.data = tile.data.copy()
        dup.name = f"{tile.name}_dup_for_bool"
        # Link to the same collection(s) as the original (common behaviour)
        # If the original isn't in any collection, link to current collection
        if tile.users_collection:
            for coll in tile.users_collection:
                coll.objects.link(dup)
        else:
            bpy.context.collection.objects.link(dup)

        # Make sure duplicate is selected and active
        bpy.ops.object.select_all(action='DESELECT')
        dup.select_set(True)
        bpy.context.view_layer.objects.active = dup

        # Add Solidify modifier to create an extrusion (thickness in Blender units)
        # We set use_rim to True so caps are created, giving a closed volume suitable for Boolean
        #solid_mod = dup.modifiers.new(name="__auto_solidify__", type='SOLIDIFY')
        #solid_mod.thickness = extrude_amount
        #solid_mod.offset = 1.0    # push outwards relative to normals
        #solid_mod.use_rim = True
        #solid_mod.use_even_offset = True
        dup.scale.z = 50

        # Apply the Solidify modifier (ensure we're in OBJECT mode)
        if bpy.context.mode != 'OBJECT':
            bpy.ops.object.mode_set(mode='OBJECT')
        #bpy.ops.object.modifier_apply(modifier=solid_mod.name)

        # Ensure the duplicate has up-to-date transforms applied for Boolean reliability
        # (optional but often useful)
        bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)

        # Prepare the Element object for boolean
        bpy.ops.object.select_all(action='DESELECT')
        element.select_set(True)
        bpy.context.view_layer.objects.active = element

        bool_mod = element.modifiers.new(name="__auto_boolean__", type='BOOLEAN')
        bool_mod.operation = 'INTERSECT'
        bool_mod.object = dup
        bool_mod.solver = 'MANIFOLD'

        # Apply the boolean modifier
        if bpy.context.mode != 'OBJECT':
            bpy.ops.object.mode_set(mode='OBJECT')
        bpy.ops.object.modifier_apply(modifier=bool_mod.name)

        # Delete the duplicated tile
        bpy.ops.object.select_all(action='DESELECT')
        dup.select_set(True)
        bpy.context.view_layer.objects.active = dup
        bpy.ops.object.delete()

        # Restore previous active object and mode (if possible)
        if prev_active and prev_active.name in bpy.data.objects:
            bpy.context.view_layer.objects.active = prev_active
        try:
            if prev_mode != bpy.context.mode:
                bpy.ops.object.mode_set(mode=prev_mode)
        except Exception:
            # ignoring mode restore errors (some modes cannot be restored trivially)
            pass

        return True, "Boolean INTERSECT applied and duplicate tile removed."

    except Exception as e:
        # Attempt to clean up the duplicate if it exists
        dup_obj = bpy.data.objects.get(f"{tile.name}_duplicate_for_bool")
        if dup_obj:
            try:
                bpy.ops.object.select_all(action='DESELECT')
                dup_obj.select_set(True)
                bpy.context.view_layer.objects.active = dup_obj
                bpy.ops.object.delete()
            except Exception:
                pass
        return False, f"Error: {e}"

def intersect_alltrails_with_existing_box(cutobject):
    #cutobject is the object that will be cut to the Map shapes
    cutobject.scale.z = 1000


    robj2 = None
    
    bpy.ops.object.select_all(action='DESELECT')
    
    cutobject.select_set(True)
    bpy.context.view_layer.objects.active = cutobject
    bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
    
    #cube = bpy.data.objects.get(cutobject)
    cube = cutobject
    if not cube:
        print(f"Object named '{cutobject}' not found.")
        return

    # Get cube's bounding box in world coordinates
    cube_bb = [cube.matrix_world @ Vector(corner) for corner in cube.bound_box]


    def is_point_inside_cube(point, bb):
        min_corner = Vector((min(v[0] for v in bb),
                             min(v[1] for v in bb),
                             min(v[2] for v in bb)))
        max_corner = Vector((max(v[0] for v in bb),
                             max(v[1] for v in bb),
                             max(v[2] for v in bb)))
        return all(min_corner[i] <= point[i] <= max_corner[i] for i in range(3))
    done = False
    boolObjects = []
    trail_mesh = None
    for robj in bpy.data.objects:
        if "_Trail" in robj.name and robj.type in {'CURVE', 'MESH'}:
            if not robj.hide_get():
                # Convert curve to mesh
                if robj.type == 'CURVE':
                    bpy.context.view_layer.objects.active = robj
                    bpy.ops.object.select_all(action='DESELECT')
                    robj2 = robj.copy()
                    robj2.data = robj.data.copy()
                    bpy.context.collection.objects.link(robj2)
                    robj2.select_set(True)
                    bpy.ops.object.convert(target='MESH')
                    trail_mesh = robj2
                else:
                    trail_mesh = robj
                
                #robj.hide_set(True)

                if trail_mesh:
                    if trail_mesh.type == "MESH" and len(trail_mesh.data.vertices) > 0:
                        # Check if any vertex is inside the cube
                        for v in trail_mesh.data.vertices:
                            global_coord = trail_mesh.matrix_world @ v.co
                            if is_point_inside_cube(global_coord, cube_bb):
                                # Apply Boolean modifier
                                #print(f"{trail_mesh.name} is inside the Boundaries")
                                if trail_mesh not in boolObjects:
                                    boolObjects.append(trail_mesh)
                                #Set done to True so it doesnt delete the object later
                                done = True
                                #Change Collection
                                continue  # No need to keep checking this object
                            else:
                                pass
                                #print(f"{trail_mesh.name} is NOT inside the Boundaries")
                    else:
                        print("No Vertices for Trail Found")
                        bpy.data.objects.remove(trail_mesh, do_unlink=True)
                
                #bpy.data.objects.remove(robj, do_unlink=True)
                #break
    if done == False:
        print("No matching trail found. removing cutobject")
        bpy.data.objects.remove(cutobject, do_unlink=True)
        if trail_mesh:
            bpy.data.objects.remove(trail_mesh, do_unlink=True)
    
    #Pfade kopieren, zusammenfügen und die boolean operation mit allen trails kombiniert ausführen
    if done == True:
        copied_objects = []
        #Copy objects
        for obj in boolObjects:
            obj_copy = obj.copy()
            obj_copy.data = obj.data.copy()
            bpy.context.collection.objects.link(obj_copy)
            copied_objects.append(obj_copy)
        
        #Deselect all
        bpy.ops.object.select_all(action='DESELECT')

        #Select all copied objects and make one active
        for obj in copied_objects:
            obj.select_set(True)
        bpy.context.view_layer.objects.active = copied_objects[0]

        #Join them into a single object
        bpy.ops.object.join()

        merged_object = bpy.context.active_object

        bool_mod = cube.modifiers.new(name=f"Intersect", type='BOOLEAN')
        bool_mod.operation = 'INTERSECT'
        bool_mod.object = merged_object
        bpy.context.view_layer.objects.active = cube
        bpy.ops.object.modifier_apply(modifier=bool_mod.name)

        bpy.data.objects.remove(merged_object, do_unlink=True)
        if robj2 != None:
            bpy.data.objects.remove(robj2, do_unlink=True)  

        mat = bpy.data.materials.get("TRAIL")
        cube.data.materials.clear()
        cube.data.materials.append(mat)



        writeMetadata(cube,"TRAIL")


def intersect_trail_with_existing_box(cutobject,trail):
    #cutobject is the object that will be cut to the Map shapes
    cutobject.scale.z = 1000


    robj2 = None
    
    bpy.ops.object.select_all(action='DESELECT')
    
    cutobject.select_set(True)
    bpy.context.view_layer.objects.active = cutobject
    bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
    
    #cube = bpy.data.objects.get(cutobject)
    cube = cutobject
    if not cube:
        print(f"Object named '{cutobject}' not found.")
        return

    # Get cube's bounding box in world coordinates
    cube_bb = [cube.matrix_world @ Vector(corner) for corner in cube.bound_box]


    def is_point_inside_cube(point, bb):
        min_corner = Vector((min(v[0] for v in bb),
                             min(v[1] for v in bb),
                             min(v[2] for v in bb)))
        max_corner = Vector((max(v[0] for v in bb),
                             max(v[1] for v in bb),
                             max(v[2] for v in bb)))
        return all(min_corner[i] <= point[i] <= max_corner[i] for i in range(3))
    done = False
    boolObjects = []
    if trail.type == 'CURVE':
        bpy.context.view_layer.objects.active = trail
        bpy.ops.object.select_all(action='DESELECT')
        robj2 = trail.copy()
        robj2.data = trail.data.copy()
        bpy.context.collection.objects.link(robj2)
        robj2.select_set(True)
        bpy.ops.object.convert(target='MESH')
        trail_mesh = robj2
    
    #robj.hide_set(True)

    if trail_mesh:
        if trail_mesh.type == "MESH" and len(trail_mesh.data.vertices) > 0:
            # Check if any vertex is inside the cube
            for v in trail_mesh.data.vertices:
                global_coord = trail_mesh.matrix_world @ v.co
                if is_point_inside_cube(global_coord, cube_bb):
                    # Apply Boolean modifier
                    #print(f"{trail_mesh.name} is inside the Boundaries")
                    if trail_mesh not in boolObjects:
                        boolObjects.append(trail_mesh)
                    #Set done to True so it doesnt delete the object later
                    done = True
                    #Change Collection
                    continue  # No need to keep checking this object
                else:
                    pass
                    #print(f"{trail_mesh.name} is NOT inside the Boundaries")
        else:
            print("No Vertices for Trail Found")
            bpy.data.objects.remove(trail_mesh, do_unlink=True)
    

    if done == False:
        print("No matching trail found. removing cutobject")
        bpy.data.objects.remove(cutobject, do_unlink=True)
        if trail_mesh:
            bpy.data.objects.remove(trail_mesh, do_unlink=True)
    #Pfade kopieren, zusammenfügen und die boolean operation mit allen trails kombiniert ausführen
    if done == True:
        copied_objects = []
        #Copy objects
        for obj in boolObjects:
            obj_copy = obj.copy()
            obj_copy.data = obj.data.copy()
            bpy.context.collection.objects.link(obj_copy)
            copied_objects.append(obj_copy)
        
        #Deselect all
        bpy.ops.object.select_all(action='DESELECT')

        #Select all copied objects and make one active
        for obj in copied_objects:
            obj.select_set(True)
        bpy.context.view_layer.objects.active = copied_objects[0]

        #Join them into a single object
        bpy.ops.object.join()

        merged_object = bpy.context.active_object

        bool_mod = cube.modifiers.new(name=f"Intersect", type='BOOLEAN')
        bool_mod.operation = 'INTERSECT'
        bool_mod.object = merged_object
        bpy.context.view_layer.objects.active = cube
        bpy.ops.object.modifier_apply(modifier=bool_mod.name)

        bpy.data.objects.remove(merged_object, do_unlink=True)
        if robj2 != None:
            bpy.data.objects.remove(robj2, do_unlink=True)  

        mat = bpy.data.materials.get("TRAIL")
        cube.data.materials.clear()
        cube.data.materials.append(mat)



        writeMetadata(cube,"TRAIL")

def separate_duplicate_xy(coordinates, offset=0.05):
    seen_xy = set()

    for i, point in enumerate(coordinates):
        # Convert tuple to list if needed
        if isinstance(point, tuple):
            point = list(point)
            coordinates[i] = point  # Update the original array with the list version

        x, y, z = point[0], point[1], point[2]
        xy_key = (x, y,z)

        if xy_key in seen_xy:
            point[2] += offset
            point[1] += offset
            #print("Duplicate")
        else:
            seen_xy.add(xy_key)
    
    return(coordinates)

def single_color_mode_curve(crv, map, keepTolTrail = False, cutDepth = 2, projectionObj = None):

    if projectionObj == None:
        projectionObj = map

    tol = bpy.context.scene.tp3d.tolerance #Tolerance between Map and the Trail on each side (0.2 worked great so far)
    minThickness = bpy.context.scene.tp3d.minThickness
    pathThickness = bpy.context.scene.tp3d.pathThickness

    lowestZonCurve = 1000

    trailCutDepth = min(cutDepth, minThickness/2) # How deep the trail will be placed into the map
                                            # Either 2mm or for flatter maps half of the minThickness

    if crv.type == "CURVE":
        
        #Getting the lowest Point of the Curve
        curve = crv.data
        for spline in curve.splines:
            if hasattr(spline, "points") and len(spline.points) > 0:
                for p in spline.points:
                    co_local = Vector((p.co.x, p.co.y, p.co.z))
                    co_world = crv.matrix_world @ co_local
                    z = co_local.z
                    if lowestZonCurve is None or z < lowestZonCurve:
                        lowestZonCurve = z

        #print(f"lowestzoncurve: {lowestZonCurve}")


        crv_data = crv.data
        crv_data.dimensions = "2D"
        crv_data.dimensions = "3D"
        crv_data.extrude = 200


        # Ensure the text object is selected and active
        bpy.ops.object.select_all(action='DESELECT')
        crv.select_set(True)
        bpy.context.view_layer.objects.active = crv

        bpy.ops.object.mode_set(mode='EDIT')

        # select all points if you want to smooth everything
        bpy.ops.curve.select_all(action='SELECT')

        # run the smooth operator   
        bpy.ops.curve.smooth()

        # back to Object Mode if you like
        bpy.ops.object.mode_set(mode='OBJECT')

        #Create a duplicate object of the curve that will be slightly thicker
        crv_thick = crv.copy()
        crv_thick.data = crv.data.copy()
        crv_thick.data.bevel_depth = pathThickness/2 + tol  # Set the thickness of the curve
        bpy.context.collection.objects.link(crv_thick)
    elif crv.type == "MESH":
        
        depsgraph = bpy.context.evaluated_depsgraph_get()
        eval_obj = crv.evaluated_get(depsgraph)
        mesh = eval_obj.to_mesh()
        lowestZonCurve = min((crv.matrix_world @ v.co).z for v in mesh.vertices)

        #crv.scale.z = 100

        crv_thick = crv.copy()
        crv_thick.data = crv.data.copy()
        #crv_thick.data.scale = 1.02
        bpy.context.collection.objects.link(crv_thick)

    bpy.ops.object.convert(target='MESH')

    recalculateNormals(crv)

    # Add boolean modifier
    bool_mod = crv.modifiers.new(name="Boolean", type='BOOLEAN')
    bool_mod.object = projectionObj
    bool_mod.operation = 'INTERSECT'
    bool_mod.solver = 'MANIFOLD'


    bpy.ops.object.modifier_apply(modifier=bool_mod.name)


    recalculateNormals(crv)

    #Adding another Intersect Modifier to make the path "Plane" with the Map
    # Add boolean modifier
    bool_mod = crv.modifiers.new(name="Boolean", type='BOOLEAN')
    bool_mod.object = projectionObj
    bool_mod.operation = 'INTERSECT'
    bool_mod.solver = 'MANIFOLD'

    recalculateNormals(crv)


    bpy.ops.object.modifier_apply(modifier=bool_mod.name)

    #doing the same for the duplicate
    bpy.ops.object.select_all(action='DESELECT')
    crv_thick.select_set(True)
    bpy.context.view_layer.objects.active = crv_thick
    bpy.ops.object.convert(target='MESH')


    # Boolean to Cut off the Extruded trail thats sticking out at the bottom and the top
    bool_mod = crv_thick.modifiers.new(name="Boolean", type='BOOLEAN')
    bool_mod.object = projectionObj
    bool_mod.operation = 'INTERSECT'
    bool_mod.solver = 'MANIFOLD'

    bpy.ops.object.modifier_apply(modifier=bool_mod.name)
    bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY', center='BOUNDS')
    crv_thick.scale = (1.002,1.002,1)

    recalculateNormals(crv_thick)

    # thicker curve is currently flat with the bottom of the Map so we need to move it upwards before creating the cutout
    # Move the thicker curve upwards
    crv_thick.location.z += lowestZonCurve - trailCutDepth
    #crv_thick.location.z += 1


    bpy.ops.object.select_all(action='DESELECT')
    map.select_set(True)
    bpy.context.view_layer.objects.active = map

    # Boolean to create the Cutout
    bool_mod = map.modifiers.new(name="Boolean", type="BOOLEAN")
    bool_mod.object = crv_thick
    bool_mod.operation = "DIFFERENCE"
    bool_mod.solver = "MANIFOLD"
    bpy.ops.object.modifier_apply(modifier = bool_mod.name)

    recalculateNormals(map)

    bpy.ops.object.select_all(action='DESELECT')
    crv.select_set(True)
    bpy.context.view_layer.objects.active = crv

    recalculateNormals(crv)
    #crv.scale = (0.998,0.998,1)
    crv.location.z += 0.1
    map.scale = (1.002,1.002,1)
    bool_mod = crv.modifiers.new(name = "Boolean", type = "BOOLEAN")
    bool_mod.object = map
    bool_mod.operation = "DIFFERENCE"
    bool_mod.solver = "MANIFOLD"
    bpy.ops.object.modifier_apply(modifier = bool_mod.name)

    map.scale = (1.00,1.00,1)

    crv_thick.location.z -= 0.1
    #crv.location.z += lowestZonCurve - trailCutDepth
    recalculateNormals(crv)

    #Remove the last material from the MAP as the boolean operation adds it to the list witout using it
    #Without removing it will color the next boolean operation in the color of the trail
    mats = map.data.materials



    if keepTolTrail == False:
        bpy.data.objects.remove(crv_thick, do_unlink = True)
    else:
        return(crv_thick)



def applyModifier(obj, modifier):
        depsgraph = bpy.context.evaluated_depsgraph_get()
        eval_obj = obj.evaluated_get(depsgraph)

        new_mesh = bpy.data.meshes.new_from_object(eval_obj)

        old_mesh = obj.data
        obj.data = new_mesh
        obj.modifiers.remove(modifier)

        bpy.data.meshes.remove(old_mesh)

def single_color_mode_mesh(original, map, tolerance = None):

    #Original = Element usually
    if tolerance == None:
        tolerance = bpy.context.scene.tp3d.toleranceElements

    voxelSize = 0.1 


    #recalculateNormals(original)

    obj = original.copy()             # copy the object
    obj.data = obj.data.copy()   # copy the mesh (optional: if you want unique mesh)
    bpy.context.collection.objects.link(obj)  # link to current collection 

    #extrude the obj so the remesh doesnt create weird bevels on the top -> prevent overhangs

    selectBottomFaces(obj)

    #bpy.ops.mesh.extrude_region_move()
    bpy.ops.transform.translate(value=(0, 0, -1))#bpy.ops.mesh.select_all(action='DESELECT')
    bpy.ops.object.mode_set(mode='OBJECT')

    obj.location.z += 1

    # Solidify on Duplicate to "upscale it" and create the tolerance
    solid = obj.modifiers.new(name="Solidify", type='SOLIDIFY')
    solid.offset = 1.0
    solid.thickness = tolerance/2
    applyModifier(obj, solid)

    # Remesh (Voxel) on Duplicate
    #remesh = obj.modifiers.new(name="Remesh", type='REMESH')
    #remesh.mode = 'VOXEL'
    #remesh.voxel_size = 0.4
    #remesh.use_smooth_shade = True

     # Remesh (Voxel) on Duplicate
    remesh = obj.modifiers.new(name="Remesh", type='REMESH')
    remesh.mode = 'Sharp'
    remesh.voxel_size = 0.4
    remesh.use_smooth_shade = True
    applyModifier(obj, remesh)

    applyModifier(obj, remesh)
    

    # Remesh (Voxel) on Duplicate
    remesh = obj.modifiers.new(name="Remesh", type='REMESH')
    remesh.mode = 'VOXEL'
    remesh.voxel_size = voxelSize
    remesh.use_smooth_shade = True
    applyModifier(obj, remesh)


    # Boolean on map
    boolean = map.modifiers.new(name="Boolean", type='BOOLEAN')
    boolean.operation = 'DIFFERENCE'
    boolean.object = obj
    boolean.solver = 'MANIFOLD'


    applyModifier(map, boolean)


    # Remesh (Voxel) on the Original part so its easier to print by smoothing out the sharp edges
    remesh = original.modifiers.new(name="Remesh", type='REMESH')
    remesh.mode = 'VOXEL'
    remesh.voxel_size = voxelSize
    remesh.use_smooth_shade = True
    applyModifier(original, remesh)


    #remove_objects(obj)
    return obj

def fetch_osm_data(bbox, kind="WATER", max_cache_age_hours=720, return_cache_status=False):
    #print("FETCH OSM:", kind)

    disableCache = bpy.context.scene.tp3d.disableCache
    apiRetries = bpy.context.scene.tp3d.apiRetries
    mapsize = bpy.context.scene.tp3d.sMapInKm

    def get_cache_dir():
        path = const.overpass_cache_dir
        os.makedirs(path, exist_ok=True)
        return path


    def make_cache_key(bbox, kind):
        south, west, north, east = bbox
        payload = {
            "bbox": [round(south, 7), round(west, 7), round(north, 7), round(east, 7)],
            "kind": kind
        }
        data = json.dumps(payload, sort_keys=True).encode("utf-8")
        return hashlib.sha256(data).hexdigest()

    cache_dir = get_cache_dir()
    cache_key = make_cache_key(bbox, kind)
    if kind == "STREETS":
        cache_key = make_cache_key(bbox, kind + str(mapsize))
    cache_path = os.path.join(cache_dir, f"{cache_key}.json")

    # --------------------------------------------------
    # Use cache if fresh
    # --------------------------------------------------
    if os.path.exists(cache_path) and disableCache == 0:
        age_hours = (time.time() - os.path.getmtime(cache_path)) / 3600
        if age_hours < max_cache_age_hours:
            print("Cached Data found")
            with open(cache_path, "r", encoding="utf-8") as f:
                data = json.load(f)
                return (data, True) if return_cache_status else data


    south, west, north, east = bbox
    overpass_url = "https://overpass-api.de/api/interpreter"

    # --------------------------------------------------
    # Build query
    # Each entry is a callable (south, west, north, east, **ctx) -> query string.
    # ctx carries extra context (e.g. mapsize) for kinds that need dynamic filters.
    # To add a new OSM kind, add one entry to this dict.
    # --------------------------------------------------
    def _bbox_header(s, w, n, e):
        return f"[out:json][timeout:60][bbox:{s},{w},{n},{e}]"

    def _simple_query(s, w, n, e, filters):
        """Build a standard area query from a list of tag-filter strings."""
        lines = "\n".join(f"        {f};" for f in filters)
        return f"""
        {_bbox_header(s, w, n, e)};
        (
{lines}
        );
        out body;
        >;
        out skel qt;
        """

    OSM_QUERY_BUILDERS = {
        "WATER": lambda s, w, n, e, **_: _simple_query(s, w, n, e, [
            'way["natural"="water"]',
            'relation["natural"="water"]',
            'way["water"="river"]',
            'relation["water"="river"]',
            'way["water"="lake"]',
            'relation["water"="lake"]',
        ]),
        "FOREST": lambda s, w, n, e, **_: _simple_query(s, w, n, e, [
            'way["natural"="wood"]',
            'relation["natural"="wood"]',
            'way["landuse"="forest"]',
            'relation["landuse"="forest"]',
        ]),
        "SCREE": lambda s, w, n, e, **_: _simple_query(s, w, n, e, [
            'nwr["natural"="scree"]',
            'nwr["natural"="stone"]',
            'nwr["natural"="boulder"]',
            'nwr["natural"="rock"]',
            'nwr["natural"="bare_rock"]',
        ]),
        "CITY": lambda s, w, n, e, **_: _simple_query(s, w, n, e, [
            'way["landuse"~"residential|urban|commercial|industrial"]',
            'relation["landuse"~"residential|urban|commercial|industrial"]',
        ]),
        "FARMLAND": lambda s, w, n, e, **_: _simple_query(s, w, n, e, [
            'way["landuse"="farmland"]',
            'way["landuse"="farmyard"]',
            'relation["landuse"="farmland"]',
            'relation["landuse"="farmyard"]',
        ]),
        "GLACIER": lambda s, w, n, e, **_: _simple_query(s, w, n, e, [
            'way["natural"="glacier"]',
            'relation["natural"="glacier"]',
        ]),
        "COASTLINE": lambda s, w, n, e, **_: _simple_query(s, w, n, e, [
            'way["natural"="coastline"]',
        ]),
        "BUILDINGS": lambda s, w, n, e, **_: _simple_query(s, w, n, e, [
            'nwr["building"]',
        ]),
        "STREETS": lambda s, w, n, e, mapsize=0, **_: _build_streets_query(s, w, n, e, mapsize),
    }

    def _build_streets_query(s, w, n, e, mapsize):
        if mapsize > const.STREETS_MAJOR_ONLY_THRESHOLD:
            filter_str = '["highway"~"^(motorway|trunk)$"]'
        elif mapsize > const.STREETS_PRIMARY_THRESHOLD:
            filter_str = '["highway"~"^(motorway|trunk|primary|secondary)$"]'
        else:
            filter_str = '["highway"]'
        print(f"Filter str: {filter_str}")
        return _simple_query(s, w, n, e, [f"way{filter_str}"])

    builder = OSM_QUERY_BUILDERS.get(kind)
    if builder is None:
        raise ValueError(f"Unknown OSM kind: {kind}")
    query = builder(south, west, north, east, mapsize=mapsize)

    # --------------------------------------------------
    # Request with retries
    # --------------------------------------------------
    for attempt in range(apiRetries):
        try:
            response = requests.post(
                overpass_url,
                data={"data": query},
                timeout=60
            )

            #print("Status:", response.status_code)

            if response.status_code == 200:
                data = response.json()

                # --------------------------------------------------
                # Write cache
                # --------------------------------------------------
                with open(cache_path, "w", encoding="utf-8") as f:
                    json.dump(data, f)

                return (data, False) if return_cache_status else data

            elif response.status_code != 200:
                print(f"Status ({response.status_code}), retrying... {attempt + 1}/{apiRetries}")
                time.sleep(5 + attempt)

            #else:
            #    print("Response preview:\n", response.text[:1000])

        except requests.exceptions.Timeout:
            print(f"Request timed out (attempt {attempt + 1}/{apiRetries})")
            _ov = _progress.ProgressOverlay.get()
            if _ov.active:
                _ov.update(message=f"Timed out — retrying… ({attempt + 1}/{apiRetries})")
            time.sleep(5)
        except Exception as e:
            print("Request failed:", e)
            time.sleep(5)

    print("Overpass request failed after retries")
    _progress.WarningsOverlay.add_warning(f"failed to fetch {kind} elements from Overpass API", "error")
    return None


def extract_multipolygon_bodies(elements, nodes):
    # Helper to get coordinates of a way by its node ids
    def way_coords(way):
        return [ (nodes[nid]['lat'], nodes[nid]['lon'], nodes[nid].get('elevation', 0)) for nid in way['nodes'] if nid in nodes ]

    # Store all multipolygon lakes as lists of outer rings (each ring = list of coords)
    multipolygon_lakes = []
    multipolycon_negatives = []

    # Index ways by their id for quick lookup
    way_dict = {el['id']: el for el in elements if el['type'] == 'way'}

    for el in elements:
        if el['type'] == 'relation':
            # Collect outer and inner member ways
            outer_ways = []
            inner_ways = []

            for member in el.get('members', []):
                if member['type'] != 'way':
                    continue
                way = way_dict.get(member['ref'])
                if not way:
                    continue

                role = member.get('role', '')
                if role == 'outer':
                    outer_ways.append(way)
                elif role == 'inner':
                    inner_ways.append(way)

            # Stitch ways to closed loops for outer and inner rings
            def stitch_ways(ways):
                loops = []
                # Convert ways to deque of coord lists for O(1) popleft
                ways_dq = deque(way_coords(w) for w in ways)

                while ways_dq:
                    current = ways_dq.popleft()
                    changed = True
                    while changed:
                        changed = False
                        remaining = deque()
                        while ways_dq:
                            w = ways_dq.popleft()
                            if not w:
                                continue
                            # Check if current end connects to w start or end
                            if current[-1] == w[0]:
                                current.extend(w[1:])
                                changed = True
                            elif current[-1] == w[-1]:
                                current.extend(reversed(w[:-1]))
                                changed = True
                            # Also check if current start connects to w end or start
                            elif current[0] == w[-1]:
                                current = w[:-1] + current
                                changed = True
                            elif current[0] == w[0]:
                                current = list(reversed(w[1:])) + current
                                changed = True
                            else:
                                remaining.append(w)
                        ways_dq = remaining
                    loops.append(current)

                return loops

            outer_loops = stitch_ways(outer_ways)
            inner_loops = stitch_ways(inner_ways)

            OSM_MAX_POLYGON_VERTS = 300000
            for loop in outer_loops:
                if len(loop) > OSM_MAX_POLYGON_VERTS:
                    print(f"Skipping OSM outer ring with {len(loop)} nodes (limit {OSM_MAX_POLYGON_VERTS})")
                    _progress.WarningsOverlay.add_warning("once Very large instance polygon was removed due to its complex shape", "warn")
                    continue
                multipolygon_lakes.append(loop)
            for loop in inner_loops:
                if len(loop) > OSM_MAX_POLYGON_VERTS:
                    _progress.WarningsOverlay.add_warning("once Very large instance polygon was removed due to its complex shape", "warn")
                    print(f"Skipping OSM inner ring with {len(loop)} nodes (limit {OSM_MAX_POLYGON_VERTS})")
                    continue
                multipolycon_negatives.append(loop)
    return multipolygon_lakes, multipolycon_negatives



# --- COLOR MESH CREATION ---

def col_create_line_mesh(name, coords):
    mesh = bpy.data.meshes.new(name)
    tobj = bpy.data.objects.new(name, mesh)
    bpy.context.collection.objects.link(tobj)

    bm = bmesh.new()
    verts = [bm.verts.new(c) for c in coords]
    for i in range(len(verts) - 1):
        bm.edges.new((verts[i], verts[i + 1]))
    bm.to_mesh(mesh)
    bm.free()
    return tobj


def col_create_face_mesh(name, coords):

    if len(coords) < 3:
        return  # Need at least 3 points for a face


    mesh = bpy.data.meshes.new(name)
    tobj = bpy.data.objects.new(name, mesh)
    bpy.context.collection.objects.link(tobj)

    bm = bmesh.new()
    verts = [bm.verts.new(c) for c in coords]
    try:
        bm.faces.new(verts)
    except ValueError as e:
        print(e)  # face might already exist or be invalid
    bm.to_mesh(mesh)
    bm.free()
    return tobj

def calculate_polygon_area_2d(coords):
    area = 0.0
    
    if len(coords) >= 3:
    
        n = len(coords)
        for i in range(n):
            x0, y0, z0 = coords[i]
            x1, y1, z1 = coords[(i + 1) % n]  # Wrap around to the first point
            area += (x0 * y1) - (x1 * y0)
    
    return abs(area) * 0.5

def build_osm_nodes(data):
    nodes = {}
    for element in data['elements']:
        if element['type'] == 'node':
            nodes[element['id']] = element
    return nodes

def get_building_data(bbox, max_retries=5, timeout=90):

    apiRetries = bpy.context.scene.tp3d.apiRetries


    south, west, north, east = bbox

    overpass_url = "https://overpass-api.de/api/interpreter"
    query = f"""
    [out:json][timeout:{timeout}];
    (
    way["building"]({south},{west},{north},{east});
    );
    out body;
    >;
    out skel qt;
    """

    for attempt in range(1, max_retries + 1):
        try:
            response = requests.get(overpass_url, params={'data': query}, timeout=timeout)

            
            if response.status_code != 200:

                print(f"Status ({response.status_code}), retrying... {attempt + 1}/{apiRetries}")
            else:
                # Try to parse JSON
                try:
                    data = response.json()
                    return data  # Success
                except ValueError:
                    print(f"Attempt {attempt}: Invalid JSON response")

        except requests.RequestException as e:
            print(f"Attempt {attempt}: Request error: {e}")

        # If not successful, wait before retrying
        if attempt < max_retries:
            wait_time = 2 + 1 * attempt  # exponential-ish backoff
            print(f"Retrying in {wait_time} seconds...")
            time.sleep(wait_time)

    # If we reach here, all retries failed
    print("Failed to fetch data from Overpass API after multiple attempts.")
    return None

def create_buildings(map, default_height=10, scaleHor=1.0):


    minThickness = bpy.context.scene.tp3d.minThickness
    minLat = bpy.context.scene.tp3d.minLat
    minLon = bpy.context.scene.tp3d.minLon
    maxLat = bpy.context.scene.tp3d.maxLat
    maxLon = bpy.context.scene.tp3d.maxLon
    #print(f"ADDING {kind} MESH")
    #print(f"Map name: {map.name}")


    lat_step = 2
    lon_step = 2


    if maxLat - minLat < lat_step:
        lat_step = maxLat - minLat
    if maxLon - minLon < lon_step:
        lon_step = maxLon - minLon

    lats = math.ceil((maxLat - minLat) / lat_step)
    lons = math.ceil((maxLon - minLon) / lon_step)


    #print(f"lats: {lats}, lons: {lons}")
    if lats * lons < 20:
        for k in range(lats):
            for l in range(lons):
                _cntr = (k) * lons + l + 1
                _maxcntr = lats * lons
                print(f"Buildings loop: {_cntr}/{_maxcntr}")
                _ov = _progress.ProgressOverlay.get()
                if _ov.active:
                    _ov.update(message=f"Buildings: tile {_cntr}/{_maxcntr} — fetching…")
                south = minLat + k * lat_step
                north = south + lat_step
                west = minLon + l * lon_step
                east = west + lon_step

                bbox = (south, west, north, east)
                data = []

                #data = get_building_data(bbox, apiRetries)
                data = fetch_osm_data(bbox,"BUILDINGS")

                if not data or "elements" not in data:
                    print("No Building data returned")
                    return None

                n_buildings = len([e for e in data['elements'] if e['type'] == 'way'])
                if _ov.active:
                    _ov.update(message=f"Buildings: tile {_cntr}/{_maxcntr} — creating {n_buildings} buildings…")
                # Cache node id -> (lat, lon) and node id -> (x, y, z_base) to avoid repeated conversions
                raw_nodes = {n['id']: (n['lat'], n['lon']) for n in data['elements'] if n['type'] == 'node'}

                #print(f"Building nodes: {len(raw_nodes)}")

                # compute 2D coordinates once per node (z=0 for now)
                node_xy = {}
                for nid, (nlat, nlon) in raw_nodes.items():
                    x, y, z = convert_to_blender_coordinates(nlat, nlon, 0, scaleHor)
                    node_xy[nid] = (x, y, nlat, nlon)  # keep lat/lon if you need to re-evaluate elevation later

                verts = []   # list of (x, y, z)
                faces = []   # list of index lists (quads/ngons)
                vert_count = 0

                def safe_float_height(h):
                    # supports strings like "10", "10.0", "10 m"
                    if h is None:
                        return float(default_height)
                    if isinstance(h, (int, float)):
                        return float(h)
                    try:
                        s = str(h).strip().lower()
                        # strip units like "m"
                        if s.endswith('m'):
                            s = s[:-1].strip()
                        return float(s)
                    except Exception:
                        return float(default_height)
                    

                # Build a lookup for ways by id, so relations can reference them
                ways_by_id = {e['id']: e for e in data['elements'] if e['type'] == 'way'}

                relation_elements = [e for e in data['elements'] if e['type'] == 'relation']
                print(f"[BUILDINGS] ways: {len(ways_by_id)}, relations: {len(relation_elements)}, nodes in node_xy: {len(node_xy)}")

                for i,element in enumerate(data['elements']):
                    if element['type'] == 'relation':
                        # Find the outer member way and use its nodes as the footprint
                        outer_way = None
                        for member in element.get('members', []):
                            if member.get('type') == 'way' and member.get('role') == 'outer':
                                outer_way = ways_by_id.get(member['ref'])
                                if outer_way:
                                    break
                        if outer_way is None:
                            print(f"[BUILDINGS] relation {element['id']}: no outer way found, members={element.get('members', [])[:3]}")
                            continue
                        print(f"[BUILDINGS] relation {element['id']}: outer_way={outer_way['id']}, nodes={len(outer_way.get('nodes', []))}")
                        # Treat the relation like the outer way but use relation tags if present
                        node_ids = outer_way.get('nodes', [])
                        tags = element.get('tags') or outer_way.get('tags', {})
                    elif element['type'] == 'way':
                        node_ids = element.get('nodes', [])
                        tags = element.get('tags', {})
                    else:
                        continue

                    # build 2D footprint coords from cached node_xy
                    footprint = []
                    for nid in node_ids:
                        if nid in node_xy:
                            x, y, nlat, nlon = node_xy[nid]
                            footprint.append((x, y, nlat, nlon))
                    if len(footprint) < 3:
                        continue

                    height = safe_float_height(tags.get('height', default_height))
                    levels = safe_float_height(tags.get("building:levels", 0))
                    if levels != 0:
                        height = levels * 2.7
                    #base_elevation = get_elevation_from_osm(tags) or 0.0
                    base_elevation = 0


                    #base_elevation = 0

                    zTerrainOffset = RaycastPointToMeshZ((x,y,100),map)
                    if zTerrainOffset == None:
                        zTerrainOffset = minThickness

                    # convert base_elevation to Blender z once per building (avoid reconverting lat/lon for each node)
                    z_offset = height * 0.002 * scaleHor # * base_elevation

                    n = len(footprint)
                    # Add bottom verts
                    for (x, y, nlat, nlon) in footprint:
                        # Convert node to Blender coords once (with base elevation)
                        xb, yb, zb = convert_to_blender_coordinates(nlat, nlon, 0, scaleHor)
                        verts.append((xb, yb, base_elevation))
                    # Add top verts (same XY, Z + height)
                    for (x, y, nlat, nlon) in footprint:

                        xb, yb, zb = convert_to_blender_coordinates(nlat, nlon, 0, scaleHor)
                        verts.append((xb, yb, base_elevation + z_offset + zTerrainOffset))

                    # Indices for bottom and top
                    base = vert_count
                    bottom_idx = [base + i for i in range(n)]
                    top_idx    = [base + n + i for i in range(n)]

                    # Add faces:
                    # bottom (note: Blender's face winding is important; reverse for bottom)
                    faces.append(bottom_idx[::-1])  # bottom polygon (reverse winding so normal faces down)
                    # top
                    faces.append(top_idx)          # top polygon

                    # sides: build quads (a, b, c, d) as bottom_i, bottom_i+1, top_i+1, top_i
                    for i in range(n):
                        i_next = (i + 1) % n
                        a = base + i
                        b = base + i_next
                        c = base + n + i_next
                        d = base + n + i
                        faces.append([a, b, c, d])

                    vert_count += n * 2

                obj = None
                
                if vert_count > 0:
                    # Create mesh and object
                    mesh = bpy.data.meshes.new("building_mesh")
                    mesh.from_pydata(verts, [], faces)
                    mesh.update(calc_edges=True)

                    # Create object
                    obj = bpy.data.objects.new("Buildings", mesh)
                    bpy.context.collection.objects.link(obj)

                    # Recalculate normals once after the mesh is built
                    mesh.validate(verbose=False)
                    mesh.update(calc_edges=True)
                    # Auto-smooth or recalc normals
                    # mesh.normals_split_custom_set_from_vertices(...)  # optional advanced normal handling
                    bpy.context.view_layer.update()

                    # Recalculate normals in edit mode if you need consistent normals
                    # (simple recalc: use mesh.polygons)
                    for poly in mesh.polygons:
                        poly.use_smooth = False  # flat shading for buildings; change if desired

                    # Finally, ensure object normals are correct
                    recalculateNormals(obj)

                    mat = bpy.data.materials.get("BUILDINGS")
                    obj.data.materials.clear()
                    obj.data.materials.append(mat)

                    

                return obj

def merge_objects(created_objects, new_name="MergedObject"):
    # Filter valid mesh objects
    objs = [
        obj for obj in created_objects
        if obj and obj.type == 'MESH'
    ]

    if not objs:
        return None

    # Create new mesh + object
    merged_mesh = bpy.data.meshes.new(new_name + "_Mesh")
    merged_obj = bpy.data.objects.new(new_name, merged_mesh)

    bpy.context.collection.objects.link(merged_obj)

    bm = bmesh.new()

    for obj in objs:
        temp_bm = bmesh.new()
        temp_bm.from_mesh(obj.data)

        # Transform to world space
        temp_bm.transform(obj.matrix_world)

        bm.from_mesh(temp_bm.to_mesh())

        temp_bm.free()

    bm.to_mesh(merged_mesh)
    bm.free()

    return merged_obj

def highway_default_width(highway):
    mapping = {
        "motorway": 30.0, "trunk": 18.0, "primary": 15.0, "secondary": 10.0, "footway": 3,
        "tertiary": 5.0, "residential": 3.0, "service": 3.0, "track": 3.0, "path": 1.5
    }
    return mapping.get(highway, 6.0)



def create_roads(map, default_height=10, scaleHor=1.0, mapsize = 1):
    

    minLat = bpy.context.scene.tp3d.minLat
    minLon = bpy.context.scene.tp3d.minLon
    maxLat = bpy.context.scene.tp3d.maxLat
    maxLon = bpy.context.scene.tp3d.maxLon

    streetwidthMultiplier = bpy.context.scene.tp3d.el_sMultiplier


    lat_step = 2
    lon_step = 2


    if maxLat - minLat < lat_step:
        lat_step = maxLat - minLat
    if maxLon - minLon < lon_step:
        lon_step = maxLon - minLon

    lats = math.ceil((maxLat - minLat) / lat_step)
    lons = math.ceil((maxLon - minLon) / lon_step)


    #print(f"lats: {lats}, lons: {lons}")
    if lats * lons < 20:
        for k in range(lats):
            for l in range(lons):
                _cntr = (k) * lons + l + 1
                _maxcntr = lats * lons
                print(f"Roads loop: {_cntr}/{_maxcntr}")
                _ov = _progress.ProgressOverlay.get()
                if _ov.active:
                    _ov.update(message=f"Roads: tile {_cntr}/{_maxcntr} — fetching…")

                south = minLat + k * lat_step
                north = south + lat_step
                west = minLon + l * lon_step
                east = west + lon_step

                bbox = (south, west, north, east)

                data = []

                data = fetch_osm_data(bbox, "STREETS")

                if not data or "elements" not in data:
                    print("No Road data returned")
                    return None

                # Build node dict (id -> (lat, lon))
                nodes = {el['id']:(el['lat'], el['lon']) for el in data['elements'] if el['type'] == "node"}
                print(f"Road nodes: {len(nodes)}")
                n_roads = len([e for e in data['elements'] if e['type'] == 'way'])
                if _ov.active:
                    _ov.update(message=f"Roads: tile {_cntr}/{_maxcntr} — creating {n_roads} road segments…")

                # Cache converted coordinates per node id (as Vector)
                coord_cache = {}
                for nid, (lat, lon) in nodes.items():
                    x, y, z = convert_to_blender_coordinates(lat, lon, 0, scaleHor)
                    coord_cache[nid] = Vector((x, y, 0))

                wm = bpy.context.window_manager
                wm.progress_begin(0, max(1, len(data['elements'])))

                # Group geometry by width key (rounded width to avoid float equality issues)
                groups = {}
                element_count = len(data['elements'])

                for idx, el in enumerate(data['elements']):
                    wm.progress_update(int(idx * 100 / element_count))
                    if el['type'] != "way":
                        continue
                    node_ids = el.get("nodes", [])
                    pts = [coord_cache[nid] for nid in node_ids if nid in coord_cache]
                    if len(pts) < 2:
                        continue

                    tags = el.get("tags", {}) or {}

                    # Determine width_m (prefer explicit width, then lanes, then highway fallback)
                    width_m = None
                    if "width" in tags:
                        try:
                            s = str(tags["width"]).strip().lower()
                            if s.endswith("m"):
                                s = s[:-1]
                            width_m = float(s)
                        except Exception:
                            width_m = None
                    if width_m is None and "lanes" in tags:
                        try:
                            width_m = float(tags["lanes"]) * 3.0
                        except Exception:
                            width_m = None
                    if width_m is None:
                        width_m = highway_default_width(tags.get("highway"))

                    # Grouping key -- round to millimeters to avoid tiny float diffs
                    key = round(width_m, 3)

                    if key not in groups:
                        groups[key] = {
                            'width_m': width_m,
                            'verts': [],
                            'faces': [],
                            'vert_count': 0
                        }
                    group = groups[key]

                    # Keep same streetWidth logic as before
                    streetWidth = (width_m * 0.5) * 0.2 * scaleHor * 0.02 * streetwidthMultiplier


                    # Compute segment directions and per-node perpendiculars (2D perp)
                    seg_dirs = []
                    for a, b in zip(pts[:-1], pts[1:]):
                        d = (b - a)
                        if d.length == 0:
                            seg_dirs.append(Vector((0.0, 0.0, 0.0)))
                        else:
                            seg_dirs.append(d.normalized())

                    perp_at = []
                    npts = len(pts)
                    for i_pt in range(npts):
                        if i_pt == 0:
                            dir_vec = seg_dirs[0]
                        elif i_pt == npts - 1:
                            dir_vec = seg_dirs[-1]
                        else:
                            s = seg_dirs[i_pt - 1] + seg_dirs[i_pt]
                            if s.length == 0:
                                dir_vec = seg_dirs[i_pt - 1] if seg_dirs[i_pt - 1].length != 0 else seg_dirs[i_pt]
                            else:
                                dir_vec = s.normalized()
                        perp = Vector((-dir_vec.y, dir_vec.x, 0.0))
                        if perp.length != 0:
                            perp = perp.normalized()
                        perp_at.append(perp)

                    # Create left/right vertices for each node, add to group's vert list
                    idx_pairs = []
                    for p, perp in zip(pts, perp_at):
                        terrainOffset = None
                        #if bpy.context.scene.nanocity.enableTerrain == True:
                        #    terrainOffset = RaycastPointToMeshZ(p,bpy.context.scene.nanocity.currentBaseplate)
                        #if terrainOffset != None:
                        #    terrainOffsetPoint = Vector((0,0,terrainOffset))
                        #else:
                        #    terrainOffsetPoint = Vector((0,0,-100))
                        terrainOffsetPoint = Vector((0,0,0))
                        left = p + perp * streetWidth + terrainOffsetPoint
                        right = p - perp * streetWidth + terrainOffsetPoint
                        group['verts'].append((left.x, left.y, left.z))
                        group['verts'].append((right.x, right.y, right.z))
                        a_idx = group['vert_count']
                        b_idx = group['vert_count'] + 1
                        idx_pairs.append((a_idx, b_idx))
                        group['vert_count'] += 2

                    # Create quads between consecutive node pairs (top faces)
                    for j in range(len(idx_pairs) - 1):
                        a_left, a_right = idx_pairs[j]
                        b_left, b_right = idx_pairs[j + 1]
                        group['faces'].append((a_left, b_left, b_right, a_right))

                wm.progress_end()

                # Create mesh objects for each group
                created_objects = []
                for key in sorted(groups.keys()):
                    group = groups[key]
                    if not group['verts'] or not group['faces']:
                        continue

                    width_m = group['width_m']
                    #STREETWIDTH MULTIPLIER
                    #streetWidth = (width_m * 0.5) * 0.001
                    streetWidth = (width_m * 0.5) * 0.2 * scaleHor * 0.02 * streetwidthMultiplier

                    mesh_name = f"Road_w{str(key).replace('.', '_')}"
                    mesh = bpy.data.meshes.new(mesh_name)
                    mesh.from_pydata(group['verts'], [], group['faces'])
                    mesh.update(calc_edges=True)

                    obj_name = f"Road_{str(key)}"
                    obj = bpy.data.objects.new(obj_name, mesh)
                    bpy.context.collection.objects.link(obj)

                    # Add Solidify modifier with thickness = streetWidth
                    #solidify = obj.modifiers.new("Solidify", "SOLIDIFY")
                    #solidify.thickness = streetWidth
                    #solidify.offset = 0

                    extrude_plane(obj,default_height)

                    # store width metadata
                    obj["width"] = width_m

                    created_objects.append(obj)

                # If nothing was created, return None
                if not created_objects:
                    return None

                # Apply modifiers on each object (only Solidify in this case)
                # To safely apply modifiers we need each object to be active in the view layer
                original_active = bpy.context.view_layer.objects.active
                original_selection = list(bpy.context.selected_objects)

                # Deselect all first
                bpy.ops.object.select_all(action='DESELECT')

                for obj in created_objects:
                    try:
                        obj.select_set(True)
                        bpy.context.view_layer.objects.active = obj
                        # apply all modifiers present (we expect Solidify only)
                        # copy list because applying modifies the collection
                        mods = [m.name for m in obj.modifiers]
                        for mname in mods:
                            try:
                                bpy.ops.object.modifier_apply(modifier=mname)
                            except RuntimeError as e:
                                # in some contexts modifier_apply may fail; print and continue
                                print(f"Failed to apply modifier {mname} on {obj.name}: {e}")
                        obj.select_set(False)
                    except Exception as e:
                        print(f"Error applying modifiers on {obj.name}: {e}")

                # Merge (join) all created objects into a single object
                # Re-select all created_objects, set active to the first one and join
                bpy.ops.object.select_all(action='DESELECT')
                for o in created_objects:
                    o.select_set(True)
                bpy.context.view_layer.objects.active = created_objects[0]

                try:
                    bpy.ops.object.join()
                except Exception as e:
                    print(f"Join failed: {e}")

                # The joined object is now the active object
                merged_obj = bpy.context.view_layer.objects.active

                # Shade flat and assign material
                try:
                    bpy.ops.object.shade_flat()
                except Exception:
                    pass

                # restore selection / active if needed (optional)
                bpy.ops.object.select_all(action='DESELECT')
                if merged_obj:
                    merged_obj.select_set(True)
                    bpy.context.view_layer.objects.active = merged_obj
                else:
                    # restore previous state
                    for o in original_selection:
                        o.select_set(True)
                    bpy.context.view_layer.objects.active = original_active

                return merged_obj

def merge_by_distance(obj, distance=0.01):
    # Make sure we're in Object Mode
    bpy.ops.object.mode_set(mode='OBJECT')

    mesh = obj.data
    bm = bmesh.new()
    bm.from_mesh(mesh)

    # Merge
    bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=distance)

    # Write back
    bm.to_mesh(mesh)
    bm.free()

    # Update mesh
    mesh.update()

def is_bbox_overlapping(obj1, obj2):
    # Get world-space corners of bounding boxes
    bbox1 = [obj1.matrix_world @ Vector(corner) for corner in obj1.bound_box]
    bbox2 = [obj2.matrix_world @ Vector(corner) for corner in obj2.bound_box]

    # Calculate Min/Max for each axis
    def get_min_max(bbox):
        return [min(c[i] for c in bbox) for i in range(3)], [max(c[i] for c in bbox) for i in range(3)]

    min1, max1 = get_min_max(bbox1)
    min2, max2 = get_min_max(bbox2)

    # Standard AABB overlap test
    return all(max1[i] >= min2[i] and max2[i] >= min1[i] for i in range(3))

def coloring_main(map,kind = "WATER"):

    minLat = bpy.context.scene.tp3d.minLat
    minLon = bpy.context.scene.tp3d.minLon
    maxLat = bpy.context.scene.tp3d.maxLat
    maxLon = bpy.context.scene.tp3d.maxLon

    col_KeepManifold = (bpy.context.scene.tp3d.col_KeepManifold)
    if kind == "WATER":
        col_Area = (bpy.context.scene.tp3d.col_wArea)
    if kind == "FOREST":
        col_Area = (bpy.context.scene.tp3d.col_fArea)
    if kind == "SCREE":
        col_Area = (bpy.context.scene.tp3d.col_scrArea)
    if kind == "CITY":
        col_Area = (bpy.context.scene.tp3d.col_cArea)
    if kind == "FARMLAND":
        col_Area = (bpy.context.scene.tp3d.col_faArea)
    if kind == "GLACIER":
        col_Area = (bpy.context.scene.tp3d.col_glArea)
    
    elementMode = (bpy.context.scene.tp3d.elementMode)
    exportformat = "STL"
    if elementMode == "PAINT":
        exportformat = "OBJ"

    bpy.context.scene.tp3d.exportformat = exportformat
    #print(f"ADDING {kind} MESH")
    #print(f"Map name: {map.name}")

    name = map.name

    lat_step = 2
    lon_step = 2

    waterDeleted = 0
    waterCreated = 0
    total_fetched = 0

    if maxLat - minLat < lat_step:
        lat_step = maxLat - minLat
    if maxLon - minLon < lon_step:
        lon_step = maxLon - minLon

    lats = math.ceil((maxLat - minLat) / lat_step)
    lons = math.ceil((maxLon - minLon) / lon_step)

    created_objects = []
    negative_object = []

    cntr = 0
    maxcntr = lats * lons
    #print(f"lats: {lats}, lons: {lons}")
    if lats * lons < 20:
        for k in range(lats):
            for l in range(lons):
                cntr = (k) * lons + l + 1
                print(f"{kind} loop: {((k) * lons + l + 1)}/{maxcntr}")
                _ov = _progress.ProgressOverlay.get()
                if _ov.active:
                    _ov.update(message=f"{kind.capitalize()}: tile {cntr}/{maxcntr} — fetching…")
                south = minLat + k * lat_step
                north = south + lat_step
                west = minLon + l * lon_step
                east = west + lon_step

                bbox = (south, west, north, east)
                data = []
                print("Fetching OSM")
                #data = fetch_osm_data(bbox, kind)
                try:
                    result = fetch_osm_data(bbox, kind, return_cache_status=True)
                    if not result:
                        continue
                    resp, from_cache = result
                    if not resp:
                        continue

                except Exception as e:
                    show_message_box(f"Something went wrong with fetching OSM data: {e}")
                    _progress.WarningsOverlay.add_warning(f"Something went wrong with fetching OSM data: {e}", "error")
                    continue

                data = resp
                n_features = len([e for e in data['elements'] if e['type'] == 'way'])
                if _ov.active:
                    src = "cached" if from_cache else "live"
                    _ov.update(message=f"{kind.capitalize()}: tile {cntr}/{maxcntr} — building mesh ({n_features} features, {src})…")
                nodes = build_osm_nodes(data)
                bodies, negatives = extract_multipolygon_bodies(data['elements'], nodes)
                total_fetched += n_features + len(bodies) + len(negatives)
                #print(f"Nodes: {len(nodes)}, Bodies: {len(bodies)}")

                # Track ways already consumed by relations to avoid duplicate geometry
                relation_way_ids = set()
                for el in data['elements']:
                    if el['type'] == 'relation':
                        for member in el.get('members', []):
                            if member['type'] == 'way':
                                relation_way_ids.add(member['ref'])

                for i, coords in enumerate(bodies):
                    blender_coords = [convert_to_blender_coordinates(lat, lon, ele, 0) for lat, lon, ele in coords]
                    calcArea = calculate_polygon_area_2d(blender_coords)
                    #print(f"tArea1: {calcArea}")
                    if calcArea > col_Area:
                        tobj = col_create_face_mesh(f"Relation_{i}", blender_coords)
                        created_objects.append(tobj)
                        waterCreated += 1
                    else:
                        waterDeleted += 1
                
                for i, coords in enumerate(negatives):
                    blender_coords = [convert_to_blender_coordinates(lat, lon, ele, 0) for lat, lon, ele in coords]
                    calcArea = calculate_polygon_area_2d(blender_coords)
                    #print(f"tArea1: {calcArea}")
                    if calcArea > col_Area:
                        tobj = col_create_face_mesh(f"Relation_{i}", blender_coords)
                        negative_object.append(tobj)
                        waterCreated += 1
                    else:
                        waterDeleted += 1


                for i, element in enumerate(data['elements']):
                    #print(i)
                    if element['type'] != 'way':
                        waterDeleted += 1
                        continue
                    if element['id'] in relation_way_ids:
                        continue  # already processed as part of a relation

                    coords = []
                    for node_id in element.get('nodes', []):
                        if node_id in nodes:
                            node = nodes[node_id]
                            coord = convert_to_blender_coordinates(
                                node['lat'], node['lon'], 0,0
                            )
                            coords.append(coord)
                    tArea = calculate_polygon_area_2d(coords)
                    #print(f"tArea2: {tArea}")
                    if len(coords) < 2 or tArea < col_Area:
                        waterDeleted += 1
                        continue
                    
                    tags = element.get("tags", {})
                    if coords[0] == coords[-1]:
                        tobj = col_create_face_mesh(f"coloredObject_{i}", coords)
                        created_objects.append(tobj)
                        waterCreated += 1
                    else:
                        tobj = col_create_line_mesh(f"OpenObject_{i}", coords)
                        created_objects.append(tobj)
                        waterCreated += 1
                    
                if not from_cache:
                    time.sleep(5)  # Pause to prevent request throttling
    else:
        print(f"Region too big. Cant Fetch All {kind} Sources")
        return None

    if cntr < maxcntr:
        print("Not All data fetched")
        for tobj in created_objects:
            bpy.data.objects.remove(tobj, do_unlink=True)

        print("Timed out. Cached already Fetched Data. Try Regenerating Again")
    else:
        if total_fetched == 0:
            _progress.WarningsOverlay.add_warning(f"No {kind.capitalize()} elements returned from API.", "warn")
        elif waterCreated == 0:
            _progress.WarningsOverlay.add_warning(f"All {kind.capitalize()} elements are below the area threshold.", "warn")


    #Make sure the flat faces have the correct normal orientation
    UP = Vector((0,0,1))

    if created_objects:
        for obj in created_objects:
            mesh = obj.data
            bm = bmesh.new()
            bm.from_mesh(mesh)

            bm.normal_update()

            faces_to_flip = []

            for face in bm.faces:
                # Face normal is in object-local space
                if face.normal.dot(UP) > 0:
                    faces_to_flip.append(face)

            if faces_to_flip:
                bmesh.ops.reverse_faces(bm, faces=faces_to_flip)

            # Write back to mesh
            bm.to_mesh(mesh)
            bm.free()


    #print(f"Creating {kind} Objects")
    def _process_coloring_object(tobj, map_obj, tol=0.1, extrudeVal = 200):
        """Extrude, boolean-intersect with map, separate loose parts, fix normals.
        Returns (area, [resulting_objects]). Removes tobj if it becomes empty."""

        mesh = tobj.data

        bm = bmesh.new()
        bm.from_mesh(mesh)
        if not bm.faces:
            bm.free()
            bpy.data.objects.remove(tobj, do_unlink=True)
            return 0, []
        area = sum(f.calc_area() for f in bm.faces)
        bm.free()

        # Extrude upward
        bm = bmesh.new()
        bm.from_mesh(mesh)
        geom = bm.faces[:]
        ret = bmesh.ops.extrude_face_region(bm, geom=geom)
        extruded_verts = [v for v in ret["geom"] if isinstance(v, bmesh.types.BMVert)]
        bmesh.ops.translate(bm, verts=extruded_verts, vec=Vector((0, 0, extrudeVal)))
        bm.to_mesh(mesh)
        bm.free()

        tobj.location.z -= 1
        recalculateNormals(tobj)

        # Boolean intersect with map
        bool_mod = tobj.modifiers.new(name="Boolean", type='BOOLEAN')
        bool_mod.object = map_obj
        bool_mod.operation = 'INTERSECT'
        bool_mod.solver = 'MANIFOLD'

        depsgraph = bpy.context.evaluated_depsgraph_get()
        eval_obj = tobj.evaluated_get(depsgraph)
        new_mesh = bpy.data.meshes.new_from_object(eval_obj)
        tobj.modifiers.clear()
        old_mesh = tobj.data
        tobj.data = new_mesh
        bpy.data.meshes.remove(old_mesh)
    
        # Mark lowest vertices
        bm = bmesh.new()
        bm.from_mesh(tobj.data)
        if not bm.verts:
            bm.free()
            bpy.data.objects.remove(tobj, do_unlink=True)
            return 0, []
        min_z = min(v.co.z for v in bm.verts)
        lowestVert = float("inf")
        for v in bm.verts:
            if abs(v.co.z - min_z) < tol:
                v.select = True
            else:
                v.select = False
                lowestVert = min(lowestVert, v.co.z)
        bm.to_mesh(tobj.data)
        bm.free()

        recalculateNormals(tobj)

        # Separate loose parts
        bpy.ops.object.select_all(action='DESELECT')
        tobj.select_set(True)
        bpy.context.view_layer.objects.active = tobj
        bpy.ops.object.mode_set(mode='EDIT')
        bpy.ops.mesh.separate(type='LOOSE')
        bpy.ops.object.mode_set(mode='OBJECT')

        result_objects = []
        objects_to_remove = []
        for zobj in bpy.context.selected_objects:

            mesh_area = getBottomFacesArea(zobj)
            if mesh_area < col_Area:
                zobj.location.z -= 100
                print(f"Removing {zobj.name}. Area {mesh_area}")
                objects_to_remove.append(zobj)
                continue


            DOWN = Vector((0, 0, -1))
            zmesh = zobj.data
            bm = bmesh.new()
            bm.from_mesh(zmesh)
            bm.normal_update()


            lowest_face = None
            lowest_z = float('inf')
            for face in bm.faces:
                z = face.calc_center_median().z
                if z < lowest_z and face.calc_area() > 0:
                    lowest_z = z
                    lowest_face = face

            if lowest_face and lowest_face.normal.dot(DOWN) <= 0:
                bmesh.ops.reverse_faces(bm, faces=bm.faces[:])
                bm.to_mesh(zmesh)

            bm.free()
            result_objects.append(zobj)

        remove_objects(objects_to_remove)

        return area, result_objects


    created_objects_booleaned = []
    created_negatives_booleaned = []
    merged_object = None
    if created_objects:
        print(f"Unique objects from element:{ len(created_objects)}")
        bpy.ops.object.select_all(action='DESELECT')
        biggestArea = 0
        tol = 0.1

        for cntr, tobj in enumerate(list(created_objects), start=1):
            _process_coloring_object(tobj, map, tol, extrudeVal= 150)
            #area, new_objs = _process_coloring_object(tobj, map, tol, extrudeVal= 150)
            #biggestArea = max(biggestArea, area)
            #created_objects_booleaned.extend(new_objs)
    
        for cntr, tobj in enumerate(list(negative_object), start = 1):
            area, new_objs = _process_coloring_object(tobj,map,tol, extrudeVal = 200)
            biggestArea = max(biggestArea, area)
            for to in new_objs:
                #to.location.z -=.1
                #to.scale.z *= 2
                #set_origin_to_3d_cursor(to)
                set_origin_to_geometry(to)
                to.scale.z *= 2
                
            created_negatives_booleaned.extend(new_objs)

        for o1 in created_objects_booleaned:
            for o2 in created_negatives_booleaned:
                if is_bbox_overlapping(o1,o2):
                    pass
                    boolean_operation(o1,o2)
                    recalculateNormals(o1)


        remove_objects(created_negatives_booleaned)

        #print(f"Biggest {kind} Found has a Area of: {biggestArea}")

        if biggestArea == 0:
            print("No Water Found on Tile")
            return
        
        print(f"{kind} objects to merge: {len(created_objects_booleaned)}")
        merged_object = merge_objects(created_objects_booleaned)

        
        #merged_object = ctx.view_layer.objects.active
        bpy.ops.object.origin_set(type='ORIGIN_CURSOR', center='MEDIAN')

        if merged_object is None:
            print("No Mesh left after Merging")
            return
        
        bm = bmesh.new()
        bm.from_mesh(merged_object.data)
        
        min_z = min(v.co.z for v in bm.verts)
        lowestVert = 100
        for v in bm.verts:
            if abs(v.co.z - min_z) < tol:
                pass
                #v.select = True
            else:
                #v.select = False
                if v.co.z < lowestVert and v.co.z >= bpy.context.scene.tp3d.minThickness:
                    lowestVert = v.co.z
        for v in bm.verts:
                if abs(v.co.z - min_z) < tol:
                    pass
                    v.co.z = lowestVert - 1
        
        bm.to_mesh(merged_object.data)
        bm.free()


        #bmesh.update_edit_mesh(merged_object.data)
        bpy.ops.object.mode_set(mode="OBJECT")



        #Disabled for now
        if col_KeepManifold == 0 and 1 == 0:
            delete_non_manifold(merged_object)

        merged_object.location.z += 0.2
        merged_object.name = name + "_" + kind

        bpy.context.view_layer.objects.active = merged_object
        merged_object.select_set(True)

        if merged_object:
            #print(f"Merged obj: {merged_object}, Kind: {kind}")
            writeMetadata(merged_object, kind)
            KIND_MATERIAL_OVERRIDE = {
                "SCREE": "MOUNTAIN",
            }
            mat = bpy.data.materials.get(KIND_MATERIAL_OVERRIDE.get(kind, kind))
            merged_object.data.materials.clear()
            merged_object.data.materials.append(mat)
        
        if elementMode == "SINGLECOLORMODE":
            export_to_STL(merged_object)

        if elementMode == "PAINT":
            print("PAINTING")
            recalculateNormals(map)
            merged_object.location.z += 1
            color_map_faces_by_terrain(map, merged_object)
            mesh_data = merged_object.data

            #Delete the elements afterwards
            bpy.data.objects.remove(merged_object, do_unlink=True)
            bpy.data.meshes.remove(mesh_data)

    for area in bpy.context.screen.areas:
        if area.type == 'VIEW_3D':  # make sure it's a 3D Viewport
            for space in area.spaces:
                if space.type == 'VIEW_3D':
                    space.shading.type = 'MATERIAL'  # switch shading

                
    bpy.context.preferences.edit.use_global_undo = True

    if elementMode != "PAINT" and merged_object != None:
        return merged_object
    else:
        return None

def color_map_faces_by_terrain(map_obj, terrain_obj, up_threshold=0.05):
    """
    Loops through every face of map_obj.
    If face is facing upwards, raycasts upwards to see if terrain_obj is above.
    If yes, colors the face with terrain_obj's material.
    
    up_threshold = dot(normal, Z) must be greater than this (0.5 ~ 60° angle limit).
    """
    if map_obj.type != 'MESH' or terrain_obj.type != 'MESH':
        print("Both inputs must be mesh objects.")
        return

    recalculateNormals(map_obj)

    terrain_obj.location.z = 10
    bpy.context.view_layer.update()
    #terrain_obj.rotation_euler[0] += math.pi

    # Ensure both have mesh data
    map_mesh = map_obj.data
    terrain_mesh = terrain_obj.data

    # Build bmesh for Map
    bm = bmesh.new()
    bm.from_mesh(map_mesh)
    bm.faces.ensure_lookup_table()

    # Build BVH tree for Terrain
    #verts = [v.co for v in terrain_mesh.vertices]
    #polys = [p.vertices for p in terrain_mesh.polygons]
    #bvh = bvhtree.BVHTree.FromPolygons(verts, polys)

    depsgraph = bpy.context.evaluated_depsgraph_get()
    eval_obj = terrain_obj.evaluated_get(depsgraph)

    eval_mesh = eval_obj.to_mesh()

    bm2 = bmesh.new()
    bm2.from_mesh(eval_mesh)

    bvh = bvhtree.BVHTree.FromBMesh(bm2)

    # Get or create a material for terrain color
    if terrain_obj.active_material:
        mat = terrain_obj.active_material
    else:
        mat = bpy.data.materials.new(name="TerrainColor")
        terrain_obj.data.materials.append(mat)

    # Make sure Map has material slots
    if mat.name not in [m.name for m in map_mesh.materials]:
        map_mesh.materials.append(mat)
    mat_index = map_mesh.materials.find(mat.name)

    up = Vector((0, 0, 1))
    colored_count = 0

    i = 0
    for i, f in enumerate(bm.faces):
        normal = f.normal.normalized()
        dot = normal.dot(up)
        # Only consider faces facing upward
        if dot > up_threshold:
            center = f.calc_center_median()
            center.z -= 5
            loc, norm, idx, dist = bvh.ray_cast(center, up,100)

            #if loc is not None and dist > 0:
            if loc is not None:
                # Assign terrain material to this face
                f.material_index = mat_index
                colored_count += 1
        
    bm.to_mesh(map_mesh)
    bm.free()
    bm2.free()
    eval_obj.to_mesh_clear()
    print(f"Colored {colored_count} faces on {map_obj.name} based on {terrain_obj.name}")
    

       
def merge_with_map(mapobject, mergeobject, flatBottom = False, singleColorMode = False,):


    if mergeobject.type == "CURVE":
        print("MERGE CURVE WITH MAP")


        duplicate  = mapobject.copy()
        duplicate.data = mapobject.data.copy()
        bpy.context.collection.objects.link(duplicate)
        #intersect_alltrails_with_existing_box(duplicate)
        intersect_trail_with_existing_box(duplicate,mergeobject)
        return duplicate

    
    bpy.ops.object.select_all(action="DESELECT")

    #if the mergeobject is a Text object -> Convert it into a mesh
    if mergeobject.type == "FONT":
        mergeobject.select_set(True)
        bpy.context.view_layer.objects.active = mergeobject
        bpy.ops.object.convert(target='MESH')

    if mergeobject.type == "CURVE":
        mergeobject.select_set(True)
        bpy.context.view_layer.objects.active = mergeobject
        bpy.ops.object.convert(target='MESH')

    bpy.context.view_layer.objects.active = mergeobject
    mergeobject.select_set(True)
    bpy.ops.object.transform_apply(location=False, rotation=True, scale=True)
    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.mesh.extrude_region_move()
    bpy.ops.transform.translate(value=(0, 0, 200))#bpy.ops.mesh.select_all(action='DESELECT')
    bpy.ops.object.mode_set(mode='OBJECT')
    mergeobject.location.z = -1

    recalculateNormals(mergeobject)
    


    # Add boolean modifier
    bool_mod = mergeobject.modifiers.new(name="Boolean", type='BOOLEAN')
    bool_mod.object = mapobject
    bool_mod.operation = 'INTERSECT'
    bool_mod.solver = 'MANIFOLD'

    #apply boolean modifier
    bpy.ops.object.modifier_apply(modifier=bool_mod.name)

    bpy.ops.object.mode_set(mode="EDIT")
    bm = bmesh.from_edit_mesh(mergeobject.data)

    bm.verts.ensure_lookup_table()
    bm.faces.ensure_lookup_table()



    try:
        min_z = min(v.co.z for v in bm.verts)
    except:
        bm.free()
        bpy.ops.object.mode_set(mode='OBJECT')
        return
    
    tol = 0.1

    lowestVert = 100


    
    for v in bm.verts:
        if abs(v.co.z - min_z) < tol:
            v.select = True
        else:
            v.select = False
            if v.co.z < lowestVert:
                lowestVert = v.co.z


    if flatBottom == False: #Extrudes terrain shape down 1mm
        bpy.context.tool_settings.mesh_select_mode = (True, False, False)
        #bmesh.ops.delete(bm, geom=[f for f in bm.faces if f.select], context="FACES")
        #bmesh.ops.delete(bm, geom=[v for v in bm.verts if not v.link_faces], context='VERTS')
        bmesh.ops.delete(bm, geom=[elem for elem in bm.verts[:] + bm.edges[:] + bm.faces[:] if elem.select], context='VERTS')

        bpy.ops.mesh.select_all(action='SELECT')
        bpy.ops.mesh.extrude_region_move()
        bpy.ops.transform.translate(value=(0, 0, -1))#bpy.ops.mesh.select_all(action='DESELECT')
    elif flatBottom == True: #Extrudes and sets new faces flat to set value
        #bpy.ops.transform.translate(value=(0, 0, 1))#bpy.ops.mesh.select_all(action='DESELECT')

        lowestprojection = 100
        secondlowestprojection = 200

        bm = bmesh.from_edit_mesh(mergeobject.data)

        bm.verts.ensure_lookup_table()
        bm.faces.ensure_lookup_table()

        for v in bm.verts:
                if v.co.z < lowestprojection:
                    lowestprojection = v.co.z
                if v.co.z < secondlowestprojection and v.co.z > lowestprojection:
                    secondlowestprojection = v.co.z




        bpy.ops.transform.translate(value=(0, 0, secondlowestprojection - lowestprojection - 1), orient_type='LOCAL')
        
        #bpy.ops.mesh.select_all(action='DESELECT')
        pass




    bmesh.update_edit_mesh(mergeobject.data)
    bpy.ops.object.mode_set(mode="OBJECT")

    

    mergeobject.location.z += 0.05

    return mergeobject
    
def midpoint_spherical(lat1, lon1, lat2, lon2):
    # Convert degrees to radians
    lat1_rad = math.radians(lat1)
    lon1_rad = math.radians(lon1)
    lat2_rad = math.radians(lat2)
    lon2_rad = math.radians(lon2)

    # Convert to Cartesian coordinates
    x1 = math.cos(lat1_rad) * math.cos(lon1_rad)
    y1 = math.cos(lat1_rad) * math.sin(lon1_rad)
    z1 = math.sin(lat1_rad)

    x2 = math.cos(lat2_rad) * math.cos(lon2_rad)
    y2 = math.cos(lat2_rad) * math.sin(lon2_rad)
    z2 = math.sin(lat2_rad)

    # Average the vectors
    x = (x1 + x2) / 2
    y = (y1 + y2) / 2
    z = (z1 + z2) / 2

    # Convert back to spherical coordinates
    lon_mid = math.atan2(y, x)
    hyp = math.sqrt(x * x + y * y)
    lat_mid = math.atan2(z, hyp)

    # Convert radians back to degrees
    return math.degrees(lat_mid), math.degrees(lon_mid)

def move_coordinates(lat, lon, distance_km, direction):
    """
    Move a point a given distance (in km) in a cardinal direction (N, S, E, W).
    """
    R = const.R
    direction = direction.lower()
    
    # Convert latitude and longitude from degrees to radians
    lat_rad = math.radians(lat)
    lon_rad = math.radians(lon)

    if direction == "n":
        lat_rad += distance_km / R
    elif direction == "s":
        lat_rad -= distance_km / R
    elif direction == "e":
        lon_rad += distance_km / (R * math.cos(lat_rad))
    elif direction == "w":
        lon_rad -= distance_km / (R * math.cos(lat_rad))
    else:
        raise ValueError("Direction must be 'n', 's', 'e', or 'w'")
    
    # Convert radians back to degrees
    new_lat = math.degrees(lat_rad)
    new_lon = math.degrees(lon_rad)

    return new_lat, new_lon

def delete_non_manifold(object):

    bpy.ops.object.select_all(action="DESELECT")

    #if the mergeobject is a Text object -> Convert it into a mesh
    object.select_set(True)
    bpy.context.view_layer.objects.active = object

    # Make sure you're in edit mode
    bpy.ops.object.mode_set(mode='EDIT')

    # Get the active mesh
    obj = bpy.context.edit_object
    me = obj.data

    # Access the BMesh representation
    bm = bmesh.from_edit_mesh(me)

    # Ensure the mesh has up-to-date normals and edges
    bm.normal_update()

    # Deselect everything first (optional)
    bpy.ops.mesh.select_all(action='DESELECT')

    # Select non-manifold edges
    bpy.ops.mesh.select_non_manifold()

    # (Optional) Update the mesh to reflect selection in UI
    bmesh.update_edit_mesh(me, loop_triangles=True)

    bpy.ops.mesh.delete(type='VERT')

    bpy.ops.object.mode_set(mode='OBJECT')

def plateInsert(plate,map):

    bpy.ops.object.select_all(action="DESELECT")

    tol = bpy.context.scene.tp3d.tolerance
    dist = bpy.context.scene.tp3d.plateInsertValue
    size = bpy.context.scene.tp3d.objSize

    # Duplicate the map object
    map_copy = map.copy()
    map_copy.data = map.data.copy()
    bpy.context.collection.objects.link(map_copy)
    map_copy.scale *= (size + tol) / size

    

    plate.location.z += dist


    selectBottomFaces(map_copy)
    bpy.ops.mesh.select_all(action='INVERT')
    bpy.ops.mesh.delete(type='FACE')
    bpy.ops.mesh.select_all(action='SELECT')

    bpy.ops.mesh.extrude_region_move()
    bpy.ops.transform.translate(value=(0, 0, 100))
    bpy.ops.object.mode_set(mode='OBJECT')

    recalculateNormals(map_copy)
    bpy.ops.object.select_all(action="DESELECT")

    plate.select_set(True)
    bpy.context.view_layer.objects.active = plate

    mod = plate.modifiers.new(name="Boolean", type='BOOLEAN')
    mod.operation = 'DIFFERENCE'
    mod.solver = "MANIFOLD"
    mod.object = map_copy

    bpy.ops.object.modifier_apply(modifier = mod.name)
    
    #bpy.ops.object.origin_set(type='ORIGIN_CURSOR')

    bpy.data.objects.remove(map_copy, do_unlink=True)

def selectBottomFaces(obj):

    bpy.ops.object.select_all(action="DESELECT")
    obj.select_set(True)
    bpy.context.view_layer.objects.active = obj

    if obj is None or obj.type != 'MESH':
        raise Exception("Please select a mesh object.")


    # Enter Edit Mode
    bpy.ops.object.mode_set(mode='EDIT')
    mesh = bmesh.from_edit_mesh(obj.data)

    # Recalculate normals
    #bmesh.ops.recalc_face_normals(mesh, faces=mesh.faces)

    # Threshold for downward-facing
    threshold = -0.95

    # Object world matrix for local-to-global transformation
    world_matrix = obj.matrix_world


    for f in mesh.faces:
        if f.normal.normalized().z < threshold:
            f.select = True  # Optional: visually select in viewport
        else:
            f.select = False

    # Update the mesh
    bmesh.update_edit_mesh(obj.data, loop_triangles=False)

def getBottomFacesArea(obj):
    if obj is None or obj.type != 'MESH':
        return 0.0
    bm = bmesh.new()
    bm.from_mesh(obj.data)
    area = sum(f.calc_area() for f in bm.faces if f.normal.normalized().z < -0.95)
    bm.free()
    return area

def selectTopFaces(obj):
    if obj is None or obj.type != 'MESH':
        raise Exception("Please select a mesh object.")


    # Enter Edit Mode
    bpy.ops.object.mode_set(mode='EDIT')
    mesh = bmesh.from_edit_mesh(obj.data)

    # Recalculate normals
    bmesh.ops.recalc_face_normals(mesh, faces=mesh.faces)

    # Threshold for downward-facing
    threshold = 0.99

    # Object world matrix for local-to-global transformation
    world_matrix = obj.matrix_world


    for f in mesh.faces:
        if f.normal.normalized().z > threshold:
            f.select = True  # Optional: visually select in viewport
        else:
            f.select = False

    # Update the mesh
    bmesh.update_edit_mesh(obj.data, loop_triangles=False)

def set_origin_to_3d_cursor(tobj=None):
    if tobj is None:
        tobj = bpy.context.active_object

    bpy.ops.object.select_all(action='DESELECT')

    bpy.context.view_layer.objects.active = tobj
    tobj.select_set(True)
    bpy.ops.object.origin_set(type='ORIGIN_CURSOR')

def set_origin_to_geometry(tobj=None):
    if tobj is None:
        tobj = bpy.context.active_object

    bpy.ops.object.select_all(action='DESELECT')

    bpy.context.view_layer.objects.active = tobj
    tobj.select_set(True)
    bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY', center='BOUNDS')

def get_random_world_vertices(obj, count=5):

    """
    Returns a list of random vertex world coordinates from an object.
    Works with Meshes, Curves, Text, Surfaces, etc. by evaluating to a mesh.
    """

    depsgraph = bpy.context.evaluated_depsgraph_get()
    obj_eval = obj.evaluated_get(depsgraph)

    temp_mesh = None
    needs_free = False

    try:
        if obj_eval.type == 'MESH':
            # Direct mesh access
            mesh = obj_eval.to_mesh()
            needs_free = True
        else:
            # Convert curve / text / surface to mesh
            temp_mesh = bpy.data.meshes.new_from_object(
                obj_eval,
                depsgraph=depsgraph
            )
            mesh = temp_mesh

        if not mesh or not mesh.vertices:
            return []

        count = min(count, len(mesh.vertices))
        chosen = random.sample(mesh.vertices[:], count)

        world_mat = obj_eval.matrix_world
        world_points = [world_mat @ v.co for v in chosen]

        return world_points

    finally:
        # Cleanup
        if needs_free:
            obj_eval.to_mesh_clear()
        if temp_mesh:
            bpy.data.meshes.remove(temp_mesh)

def recalculateNormals(obj, ins = False):
    '''
    OLD WAY THAT DIDNT WORK FOR COMPLETELY FLIPPED VOLUMES


    mesh = obj.data

    bm = bmesh.new()
    bm.from_mesh(mesh)

    # recalc normals outward
    bmesh.ops.recalc_face_normals(bm, faces=bm.faces)

    bm.to_mesh(mesh)
    bm.free()
    mesh.update()
    '''
    bpy.context.view_layer.objects.active = obj
    obj.select_set(True)

    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.mesh.normals_make_consistent(inside=ins)
    bpy.ops.object.mode_set(mode='OBJECT')




def createOcean(bboxBigger,waterHeight,scaleHor,landpoints, baseplate, tile, baseHeight):

    coastcurve = create_element(bboxBigger,waterHeight,scaleHor,"COASTLINE",baseHeight * 3)
    print("coastcurve created")
    if coastcurve != None:
    
        shape = bpy.context.scene.tp3d.shape
        objSize = bpy.context.scene.tp3d.objSize
        if shape == "SQUARE":
            coastobj = create_rectangle(objSize,objSize)
        else:
            coastobj = create_rectangle(objSize,objSize)

        #extrude_plane(coastobj,waterHeight*5)
        coastobj.name = "Ocean"
        coastobj.location.x = tile.location.x
        coastobj.location.y = tile.location.y
        coastobj.location.z = 0





        flip_override = bpy.context.scene.tp3d.el_oFlip
        merged_object = cut_coastline(coastcurve, coastobj, land_hints=landpoints, flip_override=flip_override)

        remove_objects(coastcurve)

        mat = bpy.data.materials.get("WATER")
        merged_object.data.materials.clear()
        merged_object.data.materials.append(mat)
        

        elementMode = bpy.context.scene.tp3d.elementMode
        if elementMode == "PAINT":
            projection("paint",tile, merged_object)
            return None
        elif elementMode == "SINGLECOLORMODE":
            projection("singleColorMode",tile, merged_object)
            mat = bpy.data.materials.get("WATER")
            merged_object.data.materials.clear()
            merged_object.data.materials.append(mat)
            return merged_object
        elif elementMode == "SEPARATE":
            projection("separate",tile, merged_object)
            return merged_object

        



    else:
        print("NO COASTCURVE FOR SOME REASON")

def extrude_plane(obj, value=1.0, bydistance = True):

    #bydistance = True: Extrudes by value
    #bydistance = False: Extrudes and sets all vertices to the value

    # Ensure we are working on a mesh
    if obj.type != 'MESH':
        print("Not a mesh object.")
        return

    # Get mesh data and make an editable BMesh copy
    mesh = obj.data
    bm = bmesh.new()
    bm.from_mesh(mesh)

    # Select all faces (or you could select specific ones)
    for f in bm.faces:
        f.select = True

    # Perform extrusion
    ret = bmesh.ops.extrude_face_region(bm, geom=bm.faces)

    # Move the newly extruded region along its normals
    verts_extruded = [ele for ele in ret["geom"] if isinstance(ele, bmesh.types.BMVert)]
    
    if bydistance == True:
        bmesh.ops.translate(bm, verts=verts_extruded, vec=(0, 0, value))
    if bydistance == False:
        for v in verts_extruded:
            v.co.z = value

    # Write back to mesh
    bm.to_mesh(mesh)
    bm.free()

    mesh.update()
    bpy.context.view_layer.update()

def get_object_surface_area(obj, apply_modifiers=True, z_threshold = 0.00):

    if obj.type != 'MESH':
        raise TypeError(f"Object '{obj.name}' is not a mesh.")

    # Get evaluated mesh if needed
    if apply_modifiers:
        depsgraph = bpy.context.evaluated_depsgraph_get()
        obj_eval = obj.evaluated_get(depsgraph)
        mesh = obj_eval.to_mesh()
        world_matrix = obj_eval.matrix_world
    else:
        mesh = obj.data
        world_matrix = obj.matrix_world

    # Build bmesh
    bm = bmesh.new()
    bm.from_mesh(mesh)
    bm.normal_update()

    # World-space normal transform
    normal_matrix = world_matrix.to_3x3()

    total_area = 0.0

    for f in bm.faces:
        world_normal = (normal_matrix @ f.normal).normalized()

        # Count only faces pointing downward
        if world_normal.z < z_threshold:
            total_area += f.calc_area()

    # Cleanup
    bm.free()
    if apply_modifiers:
        obj_eval.to_mesh_clear()

    return total_area

def cut_coastline(curve_obj, target_obj, land_hints=None, flip_override=False):
    """
    Cut the target_obj using the curve_obj so there are multiple separate objects
    Main use case -> cut it at the coastline
    land_hints: optional list of (x, y[, z]) points known to be on land,
                used to ensure the boolean removes the land side.
    flip_override: if True, inverts the auto-detected flip decision (manual correction).
    """

    extrude_depth = -0.5
    solidify = False
    solidify_thickness = 0.02

    ctx = bpy.context
    scene = ctx.scene

    # sanity checks
    if curve_obj is None or target_obj is None:
        raise ValueError("curve_obj and target_obj must be provided")
    if curve_obj.type != 'CURVE':
        raise ValueError("curve_obj must be a Curve object")
    if target_obj.type != 'MESH':
        raise ValueError("target_obj must be a Mesh object")

    # remember current state to restore later
    prev_mode = ctx.mode

    created_objects = []
    try:
        # --- 1) get world-space points from the curve (first spline) ---
        # handle POLY or BEZIER (we read evaluated points)
        spline = None
        if len(curve_obj.data.splines) == 0:
            raise RuntimeError("Curve has no splines")
        spline = curve_obj.data.splines[0]

        # get coordinates in world space
        if 1 == 0:
            world_pts = []
            if spline.type == 'BEZIER':
                # sample bezier control points as approximate polyline (use bezier_points coordinates)
                for bp in spline.bezier_points:
                    co_local = bp.co
                    world_pts.append(curve_obj.matrix_world @ Vector((co_local.x, co_local.y, co_local.z)))
            else:
                # POLY or NURBS: spline.points (co is 4D)
                for p in spline.points:
                    co_local = Vector((p.co.x, p.co.y, p.co.z))
                    world_pts.append(curve_obj.matrix_world @ co_local)

            if len(world_pts) < 3:
                raise RuntimeError("Need at least 3 points to create a filled cutter polygon.")
        
        cutter_obj = curve_to_mesh_object(curve_obj,"Cutter")

        removeDoubles(cutter_obj)


        bm = bmesh.new()
        bm.from_mesh(cutter_obj.data)

        

        for e in bm.edges:
            e.select = True
        
        bmesh.ops.translate(bm, verts=bm.verts, vec=(0, 0, extrude_depth/2))
        geom_extrude = bmesh.ops.extrude_edge_only(bm, edges=[e for e in bm.edges])

        
        # Move new geometry
        verts_extruded = [v for v in geom_extrude["geom"] if isinstance(v, bmesh.types.BMVert)]
        bmesh.ops.translate(bm, verts=verts_extruded, vec=(0, 0, -extrude_depth))

        # Write back to mesh
        bm.to_mesh(cutter_obj.data)
        bm.free()

        # --- 2b) flip cutter normals so they point away from land (toward ocean) ---
        # extrude_edge_only normals point to the RIGHT of each edge's travel direction.
        # For a CCW-wound curve that means normals point OUTWARD; for CW they point INWARD.
        # We want normals pointing toward ocean, so we flip when normals point toward land:
        #   CCW + land outside curve  -> normals face land  -> flip
        #   CCW + land inside  curve  -> normals face ocean -> keep
        #   CW  + land inside  curve  -> normals face land  -> flip
        #   CW  + land outside curve  -> normals face ocean -> keep
        if land_hints:
            # 1) Winding: signed area of the curve polygon (shoelace)
            spline0 = curve_obj.data.splines[0]
            mw_curve = curve_obj.matrix_world
            if spline0.type == 'BEZIER':
                pts2d = [mw_curve @ bp.co for bp in spline0.bezier_points]
            else:
                pts2d = [mw_curve @ Vector((p.co.x, p.co.y, p.co.z)) for p in spline0.points]
            pts2d = [Vector((v.x, v.y)) for v in pts2d]

            signed_area = 0.0
            n_pts = len(pts2d)
            for i in range(n_pts):
                j = (i + 1) % n_pts
                signed_area += pts2d[i].x * pts2d[j].y - pts2d[j].x * pts2d[i].y
            is_ccw = signed_area > 0  # CCW -> normals outward; CW -> normals inward

            # 2) Majority vote: are most land points inside the curve polygon?
            # Ray-casting point-in-polygon (counts edge crossings along +X ray)
            def point_in_poly(px, py, poly):
                inside = False
                j = len(poly) - 1
                for i in range(len(poly)):
                    xi, yi = poly[i].x, poly[i].y
                    xj, yj = poly[j].x, poly[j].y
                    if ((yi > py) != (yj > py)) and (px < (xj - xi) * (py - yi) / (yj - yi) + xi):
                        inside = not inside
                    j = i
                return inside

            inside_count = sum(
                1 for p in land_hints
                if point_in_poly(float(p[0]), float(p[1]), pts2d)
            )
            land_is_inside = inside_count > len(land_hints) / 2

            # 3) Flip when normals point toward land; flip_override inverts the decision
            auto_flip = (is_ccw and not land_is_inside) or (not is_ccw and land_is_inside)
            should_flip = auto_flip != flip_override
            print(f"cut_coastline: is_ccw={is_ccw}, land_inside={land_is_inside}, auto_flip={auto_flip}, override={flip_override}, final={should_flip}")

            if should_flip:
                bm_flip = bmesh.new()
                bm_flip.from_mesh(cutter_obj.data)
                bmesh.ops.reverse_faces(bm_flip, faces=bm_flip.faces)
                bm_flip.to_mesh(cutter_obj.data)
                bm_flip.free()

        # ensure cutter has correct transform (we added world coords directly so keep identity)
        cutter_obj.matrix_world = Matrix() if hasattr(bpy, 'Matrix') else cutter_obj.matrix_world  # type: ignore

        created_objects.append(cutter_obj)


        # --- 3) optionally add solidify modifier (useful for thin geometry) ---
        if solidify:
            sm = cutter_obj.modifiers.new(name="CutterSolidify", type='SOLIDIFY')
            sm.thickness = solidify_thickness
            # apply the solidify modifier to get real geometry for boolean
            ctx.view_layer.objects.active = cutter_obj
            cutter_obj.select_set(True)
            # apply modifier
            try:
                pass
                #bpy.ops.object.modifier_apply(modifier=sm.name)
            except Exception as e:
                # if apply fails, continue: boolean may still work with non-applied mod
                print("Warning: failed to apply solidify modifier:", e)

        # --- 4) perform boolean difference: target_obj = target_obj - cutter_obj ---
        # ensure we are in object mode
        if ctx.mode != 'OBJECT':
            bpy.ops.object.mode_set(mode='OBJECT')

        # store list of existing objects for later diff
        before_objs = set(bpy.data.objects)


        # add boolean modifier on target
        ctx.view_layer.objects.active = target_obj
        target_obj.select_set(True)
        cutter_obj.select_set(True)

        bool_mod = target_obj.modifiers.new(name="AutoBooleanCut", type='BOOLEAN')
        bool_mod.operation = 'DIFFERENCE'
        bool_mod.object = cutter_obj
        #bool_mod.solver = 'MANIFOLD'
        bool_mod.solver = 'EXACT'
       
        # try applying modifier
        try:
            #pass
            print("APPLYING MODIFIER")
            bpy.ops.object.modifier_apply(modifier=bool_mod.name)
        except Exception as e:
            # sometimes applying fails due to non-manifold etc.
            print("Warning: boolean modifier apply failed:", e)
            # Try to apply using dependency_graph / evaluate? Fallback: try again after quick triangulate.
            # For now we raise because boolean must be applied to proceed
            raise RuntimeError("Boolean operation failed: " + str(e))

        #REMOVE THE CUTTER OBJECT
        remove_objects(cutter_obj)
        
        return target_obj

    finally:
        # ensure we return to previous mode
        try:
            if prev_mode != bpy.context.mode:
                bpy.ops.object.mode_set(mode=prev_mode)
        except Exception:
            pass

def setOriginToTerrainFace(obj,tol=0.1,seed=None,max_tries=200):

    mesh = obj.data
    if len(mesh.polygons) == 0:
        return {"success": False, "face_index": None, "center": None, "message": "Mesh has no faces"}

    # optionally seed RNG
    if seed is not None:
        random.seed(seed)

    mw = obj.matrix_world
    rot3 = mw.to_3x3()
    def face_world_normal_z(poly):
        n = poly.normal
        wn = rot3 @ n
        wn.normalize()
        return wn.z

    # collect candidate face indices that are not vertical +- tolerance
    candidates = [p.index for p in mesh.polygons if abs(face_world_normal_z(p)) >= abs(tol)]

    # Try picking random candidates (to avoid always picking the same face)
    face_idx = None
    # attempt a few random picks first
    tries = 0
    while tries < min(max_tries, len(candidates)):
        tries += 1
        idx = random.choice(candidates)
        # accept immediately (we already filtered), but keep tries logic in case you add more checks
        face_idx = idx
        break

    # fallback: if not found via random attempts, take first candidate
    if face_idx is None and candidates:
        face_idx = candidates[0]

    poly = mesh.polygons[face_idx]

    # compute face center in world coordinates (average of vertex world coords)
    center_local = Vector((0.0, 0.0, 0.0))
    for vid in poly.vertices:
        v_local = mesh.vertices[vid].co
        center_local += v_local
    center_local /= len(poly.vertices)
    center_world = mw @ center_local

    # store previous cursor location to restore later
    scene = bpy.context.scene
    prev_cursor = scene.cursor.location.copy()

    # store selection & active object & mode
    prev_active = bpy.context.view_layer.objects.active
    prev_mode = prev_active.mode if prev_active is not None else None
    prev_sel_states = {o: o.select_get() for o in bpy.context.view_layer.objects}

    try:
        # place 3D cursor at face center
        scene.cursor.location = center_world

        # make our object active and selected
        bpy.context.view_layer.objects.active = obj
        # ensure object selected
        for o in bpy.context.view_layer.objects:
            o.select_set(False)
        obj.select_set(True)

        # ensure object mode (origin_set requires object mode)
        bpy.ops.object.mode_set(mode='OBJECT', toggle=False)

        # set origin to cursor
        bpy.ops.object.origin_set(type='ORIGIN_CURSOR')

    except Exception as e:
        # restore cursor & selection before returning
        scene.cursor.location = prev_cursor
        # restore active & selection
        for o, sel in prev_sel_states.items():
            o.select_set(sel)
        bpy.context.view_layer.objects.active = prev_active
        if prev_mode:
            try:
                bpy.ops.object.mode_set(mode=prev_mode)
            except Exception:
                pass
        return {"success": False, "face_index": face_idx, "center": center_world,
                "message": f"Error while setting origin: {e}"}

    # restore cursor to previous location
    scene.cursor.location = prev_cursor

    # restore active object & selection & mode
    for o, sel in prev_sel_states.items():
        o.select_set(sel)
    bpy.context.view_layer.objects.active = prev_active
    if prev_mode:
        try:
            bpy.ops.object.mode_set(mode=prev_mode)
        except Exception:
            pass

    return

def removeDoubles(obj):

    bpy.ops.object.select_all(action='DESELECT')
    obj.select_set(True)
    bpy.context.view_layer.objects.active = obj

    bpy.ops.object.mode_set(mode="EDIT")

    bpy.ops.mesh.select_all(action="SELECT")
    bpy.ops.mesh.remove_doubles(threshold=0.0001)

    bpy.ops.object.mode_set(mode="OBJECT")

def curve_to_mesh_object(curve_obj, name=None, apply_modifiers=True):
    """
    Create and return a new Mesh object built from `curve_obj` evaluation.
    - curve_obj: bpy.types.Object of type 'CURVE'
    - name: optional name for new object (mesh)
    - apply_modifiers: if True, evaluate modifiers and use new_from_object (recommended)
    """
    if curve_obj.type != 'CURVE':
        raise ValueError("curve_obj must be a Curve object")

    mesh_name = (name if name else curve_obj.name + "_mesh")
    coll = bpy.context.collection
    depsgraph = bpy.context.evaluated_depsgraph_get()

    if apply_modifiers:
        # Create a real Mesh datablock from the evaluated object (safe to use with objects.new)
        eval_obj = curve_obj.evaluated_get(depsgraph)
        mesh = bpy.data.meshes.new_from_object(eval_obj,
                                               preserve_all_data_layers=True,
                                               depsgraph=depsgraph)
        new_obj = bpy.data.objects.new(mesh_name, mesh)
        new_obj.matrix_world = curve_obj.matrix_world.copy()
        coll.objects.link(new_obj)
        return new_obj

    else:
        # Create a temporary evaluated mesh, copy it to a real datablock, then clear the temp
        eval_obj = curve_obj.evaluated_get(depsgraph)
        temp_mesh = eval_obj.to_mesh(preserve_all_data_layers=True, depsgraph=depsgraph)
        # copy to real datablock
        real_mesh = temp_mesh.copy()
        real_mesh.name = mesh_name
        new_obj = bpy.data.objects.new(mesh_name, real_mesh)
        new_obj.matrix_world = curve_obj.matrix_world.copy()
        coll.objects.link(new_obj)
        # free the temporary evaluated mesh
        eval_obj.to_mesh_clear()
        return new_obj

def point_inside(obj, point, direction=(0,0,-1), eps=1e-6):
    """
    Check if a world-space point is inside a mesh object using raycasting.
    Handles global coordinates properly.
    """
    if not obj or obj.type != 'MESH':
        return False

    deps = bpy.context.evaluated_depsgraph_get()
    eval_obj = obj.evaluated_get(deps)

    # Build BVH in **object-local space**
    tree = bvhtree.BVHTree.FromObject(eval_obj, deps)
    if not tree:
        return False

    # Convert world-space point and direction into **object local space**
    inv_mat = eval_obj.matrix_world.inverted()
    local_point = inv_mat @ Vector(point)
    local_dir   = inv_mat.to_3x3() @ Vector(direction)
    local_dir.normalize()

    # offset slightly backward to avoid starting exactly on geometry
    origin = local_point - local_dir * eps

    hit = tree.ray_cast(origin, local_dir, 1e12)

    return bool(hit and hit[0])

def create_element(bbox, elementHeight=1.0, scaleHor=1.0, kind = "WATER", baseHeight = 1):
    
    
    col_Area = 5

    waypart = None

    data = []
    resp = fetch_osm_data(bbox, kind)

    created_objects = []
    elementDeleted = 0
    elementCreated = 0
    
    if resp == None:
        return None

    data = resp

    nodes = build_osm_nodes(data)
    bodies = extract_multipolygon_bodies(data['elements'], nodes)
    #print(f"Nodes: {len(nodes)}, Bodies: {len(bodies)}")

    for i, coords in enumerate(bodies):
        #print(i)
        blender_coords = [convert_to_blender_coordinates(lat, lon, ele, scaleHor) for lat, lon, ele in coords]
        #blender_coords = [(x,y,baseHeight) for (x, y, z) in blender_coords]
        blender_coords = [(x,y,0) for (x, y, z) in blender_coords]
        calcArea = calculate_polygon_area_2d(blender_coords)
        #print(f"tArea1: {calcArea}")
        if calcArea > col_Area:
            tobj = col_create_face_mesh(f"Relation_{i}", blender_coords)
            created_objects.append(tobj)
            elementCreated += 1
        else:
            elementDeleted += 1

    wm = bpy.context.window_manager
    wm.progress_begin(0, 100)

    for i, element in enumerate(data['elements']):
        wm.progress_update(i*100/len(nodes))

        #if element['type'] != 'way':
        #    elementDeleted += 1
        #    continue

        coords = []
        for node_id in element.get('nodes', []):
            if node_id in nodes:
                node = nodes[node_id]
                x,y,_ = convert_to_blender_coordinates(node['lat'], node['lon'], 0, scaleHor)
                #coord = (x,y,baseHeight)
                coord = (x,y,0)
                coords.append(coord)
        tArea = calculate_polygon_area_2d(coords)
        if len(coords) < 2 or (tArea < col_Area and element['type'] != 'way'):
            elementDeleted += 1
            #print(f"{len(coords)}  {tArea}")
            #print("Deleted")
            continue
        
        tags = element.get("tags", {})
        if coords[0] == coords[-1] and kind != "COASTLINE":
            tobj = col_create_face_mesh(f"coloredObject_{i}", coords)
            created_objects.append(tobj)
            elementCreated += 1
        elif kind == "COASTLINE":
            #tobj = col_create_line_mesh(f"OpenObject_{i}", coords)
            tobj = col_create_line_curve(f"coloredObject_{i}", coords, close=False)
            created_objects.append(tobj)
            tobj.select_set(False)
            elementCreated += 1
            #print(f"OpenObject_{i}")

            waypart = tobj
            #if waypart != None:
            #    return waypart
            #side = point_side_of_coastline(tobj, 40.568766,-73.-73.992)
            #print(side)


            #print(f"Ocean is on the {side} side")

    wm.progress_end()

    time.sleep(1)  # Pause to prevent request throttling


    if elementCreated > 0:
        print(f"created: {elementCreated} of {kind}")
        element = merge_objects(created_objects)

        element.name = kind

        bpy.ops.object.shade_flat()

        if kind == "WATER":
            mat = bpy.data.materials.get("BLUE")
        elif kind == "GREEN":
            mat = bpy.data.materials.get("GREEN")
        else:
            mat = bpy.data.materials.get("BLACK")
        element.data.materials.clear()
        element.data.materials.append(mat)
        extrude_plane(element,elementHeight)
        return element
    else:
        return None
    
    
def col_create_line_curve(name, coords, close=False, collection=None, bevel_depth=0.0):
    """
    Create a Curve object with a POLY spline from coords.
    coords: iterable of (x,y) or (x,y,z)
    close: make spline cyclic
    collection: bpy.types.Collection (defaults to context.collection)
    bevel_depth: >0 will give the curve thickness
    """
    if not coords:
        raise ValueError("coords is empty")

    # normalize coords to 3-tuples
    pts = []
    for c in coords:
        if len(c) == 2:
            pts.append((c[0], c[1], 0.0))
        else:
            pts.append((c[0], c[1], c[2]))

    curve_data = bpy.data.curves.new(name + "_curve", type='CURVE')
    curve_data.dimensions = '3D'
    curve_data.resolution_u = 1

    spline = curve_data.splines.new(type='POLY')
    spline.points.add(len(pts) - 1)  # one point exists by default
    for i, (x, y, z) in enumerate(pts):
        spline.points[i].co = (x, y, z, 1.0)

    spline.use_cyclic_u = bool(close)

    if bevel_depth and bevel_depth > 0.0:
        curve_data.bevel_depth = float(bevel_depth)
        curve_data.fill_mode = 'FULL'

    obj = bpy.data.objects.new(name, curve_data)
    target_col = collection or bpy.context.collection
    target_col.objects.link(obj)

    return obj

def closest_distance_between_objects(obj_a, obj_b, apply_modifiers=True):

    if obj_a.type != 'MESH' or obj_b.type != 'MESH':
        raise TypeError("Both objects must be mesh objects")

    depsgraph = bpy.context.evaluated_depsgraph_get()

    def eval_mesh(obj):
        if apply_modifiers:
            obj_eval = obj.evaluated_get(depsgraph)
            mesh = obj_eval.to_mesh(preserve_all_data_layers=False, depsgraph=depsgraph)
            mat = obj_eval.matrix_world
        else:
            mesh = obj.data
            mat = obj.matrix_world
            obj_eval = None
        return obj_eval, mesh, mat

    # --- Object A: BVH ---
    obj_a_eval, mesh_a, mat_a = eval_mesh(obj_a)

    bm_a = bmesh.new()
    bm_a.from_mesh(mesh_a)
    bm_a.transform(mat_a)

    bvh_a = bvhtree.BVHTree.FromBMesh(bm_a)

    bm_a.free()
    if obj_a_eval:
        obj_a_eval.to_mesh_clear()

    # --- Object B: iterate vertices ---
    obj_b_eval, mesh_b, mat_b = eval_mesh(obj_b)

    min_dist = float("inf")

    for v in mesh_b.vertices:
        world_co = mat_b @ v.co
        hit = bvh_a.find_nearest(world_co)

        if hit:
            _, _, _, dist = hit
            if dist < min_dist:
                min_dist = dist
                if min_dist == 0.0:
                    break  # early exit

    if obj_b_eval:
        obj_b_eval.to_mesh_clear()

    return min_dist

def merge_objects(objects, name="MergedObject"):
    """
    Simple UI-style merge: select objects, make the first one active, and call join.
    This is fast but requires changing selection/context.
    """
    # filter only mesh objects
    #mesh_objs = [o for o in objects if o.type == 'MESH']
    mesh_objs = objects
    if not mesh_objs:
        return None

    # store previous selection to restore later (optional)
    prev_active = bpy.context.view_layer.objects.active
    prev_selected = [o for o in bpy.context.selected_objects]

    # ensure in same collection / visible
    bpy.ops.object.select_all(action='DESELECT')
    for o in mesh_objs:
        o.select_set(True)
    bpy.context.view_layer.objects.active = mesh_objs[0]

    # join (applies no modifiers by default; if you want modifiers applied, make sure to apply them beforehand)
    bpy.ops.object.join()

    # the joined object is now the active object
    joined = bpy.context.view_layer.objects.active
    joined.name = name

    # restore previous selection/active (optional)
    #for o in bpy.context.selected_objects:
    #    o.select_set(False)
    #if prev_active:
    #    bpy.context.view_layer.objects.active = prev_active
    #for o in prev_selected:
    #    o.select_set(True)


    return joined

def exaggeratedLayers(objs):

    selected_objects = objs
    #cl_thickness = bpy.context.scene.tp3d.cl_thickness

    layerThickness = 1

    size = bpy.context.scene.tp3d.objSize



    if not selected_objects:
        show_message_box("No Object Selected. Please select a Map first")
        return {'CANCELLED'}

    for obj in selected_objects:

        if not "Object type" in obj:
            continue
        if obj["Object type"] != "MAP":
            continue

        objs = list(bpy.context.scene.objects)
        for o in objs:
            if "Object type" in o and "PARENT" in o:
                if o["PARENT"] == obj and  o["Object type"] == "LINES":
                    bpy.data.objects.remove(o, do_unlink=True)
        
        # Deselect everything
        bpy.ops.object.select_all(action='DESELECT')
        
        # Create plane at 3D cursor
        bpy.ops.mesh.primitive_plane_add(size=size + 10, enter_editmode=False, align='WORLD',
                                        location=bpy.context.scene.cursor.location)
        plane = bpy.context.active_object
        plane.name = "CuttingPlane"
        plane.location.z += 0.1 + layerThickness/2
        
        # Add Array modifier in Z direction
        array_mod = plane.modifiers.new(name="ArrayZ", type='ARRAY')
        array_mod.relative_offset_displace = (0, 0, 0)   # disable relative offset
        array_mod.constant_offset_displace = (0, 0, layerThickness)   # fixed step in Z
        array_mod.use_relative_offset = False
        array_mod.use_constant_offset = True
        array_mod.count = 30  # you can adjust how many slices
        
        
        # Apply modifiers up to solidify
        bpy.context.view_layer.objects.active = plane
        bpy.ops.object.modifier_apply(modifier=array_mod.name)

    
        # Add Boolean modifier with INTERSECT mode
        bool_mod = plane.modifiers.new(name="Boolean", type='BOOLEAN')
        bool_mod.operation = 'INTERSECT'
        bool_mod.solver = 'FLOAT'  # or 'EXACT'
        bool_mod.use_self = False
        bool_mod.use_hole_tolerant = True  # helps with manifold issues
        bool_mod.object = obj

        plane.name = obj.name + "_LAYERS"

        bpy.ops.object.modifier_apply(modifier=bool_mod.name)


        # Add Solidify modifier for thickness
        solidify_mod = plane.modifiers.new(name="Solidify", type='SOLIDIFY')
        solidify_mod.thickness = layerThickness
        solidify_mod.offset = 0

        bpy.ops.object.modifier_apply(modifier=solidify_mod.name)

        mat = bpy.data.materials.get("WHITE")
        plane.data.materials.clear()
        plane.data.materials.append(mat)

        writeMetadata(plane,"LINES")
        plane["PARENT"] = obj
        



    bpy.ops.object.select_all(action='DESELECT')
    for obj in selected_objects:
        obj.select_set(True)
    bpy.context.view_layer.objects.active = selected_objects[0]

def contourLines(objs):

    selected_objects = objs
    cl_thickness = bpy.context.scene.tp3d.cl_thickness
    cl_distance = bpy.context.scene.tp3d.cl_distance
    cl_offset = bpy.context.scene.tp3d.cl_offset

    size = bpy.context.scene.tp3d.objSize



    if not selected_objects:
        show_message_box("No Object Selected. Please select a Map first")
        return {'CANCELLED'}

    for obj in selected_objects:

        if not "Object type" in obj:
            continue
        if obj["Object type"] != "MAP":
            continue

        objs = list(bpy.context.scene.objects)
        for o in objs:
            if "Object type" in o and "PARENT" in o:
                if o["PARENT"] == obj and  o["Object type"] == "LINES":
                    bpy.data.objects.remove(o, do_unlink=True)
        
        # Deselect everything
        bpy.ops.object.select_all(action='DESELECT')
        
        # Create plane at 3D cursor
        bpy.ops.mesh.primitive_plane_add(size=size + 10, enter_editmode=False, align='WORLD',
                                        location=bpy.context.scene.cursor.location)
        plane = bpy.context.active_object
        plane.name = "CuttingPlane"
        plane.location.z += cl_offset
        
        # Add Array modifier in Z direction
        array_mod = plane.modifiers.new(name="ArrayZ", type='ARRAY')
        array_mod.relative_offset_displace = (0, 0, 0)   # disable relative offset
        array_mod.constant_offset_displace = (0, 0, cl_distance)   # fixed step in Z
        array_mod.use_relative_offset = False
        array_mod.use_constant_offset = True
        array_mod.count = 100  # you can adjust how many slices
        
        # Add Solidify modifier for thickness
        solidify_mod = plane.modifiers.new(name="Solidify", type='SOLIDIFY')
        solidify_mod.thickness = cl_thickness
        
        # Apply modifiers up to solidify
        bpy.context.view_layer.objects.active = plane
        bpy.ops.object.modifier_apply(modifier=array_mod.name)
        bpy.ops.object.modifier_apply(modifier=solidify_mod.name)
        
        # Add Boolean modifier with INTERSECT mode
        bool_mod = plane.modifiers.new(name="Boolean", type='BOOLEAN')
        bool_mod.operation = 'INTERSECT'
        bool_mod.solver = 'MANIFOLD'  # or 'EXACT'
        bool_mod.use_self = False
        bool_mod.use_hole_tolerant = True  # helps with manifold issues
        bool_mod.object = obj

        plane.name = obj.name + "_LINES"

        mat = bpy.data.materials.get("WHITE")
        plane.data.materials.clear()
        plane.data.materials.append(mat)

        writeMetadata(plane,"LINES")
        plane["PARENT"] = obj

        
        # Apply Boolean
        bpy.context.view_layer.objects.active = plane
        
        bpy.ops.object.modifier_apply(modifier=bool_mod.name)



    bpy.ops.object.select_all(action='DESELECT')
    for obj in selected_objects:
        obj.select_set(True)
    bpy.context.view_layer.objects.active = selected_objects[0]

def splitCurves(obj):
    if not obj or obj.type != 'CURVE':
        return []

    original_spline_count = len(obj.data.splines)
    if original_spline_count <= 1:
        return [obj]

    new_objects = []
    
    #Create a duplicate for every spline
    for i in range(original_spline_count):
        # Create a full copy of the object and its data
        new_obj = obj.copy()
        new_obj.data = obj.data.copy()
        bpy.context.collection.objects.link(new_obj)
        
        # Remove all splines EXCEPT the one for this index
        # loop backwards to avoid index shifting errors during removal
        splines = new_obj.data.splines
        for j in range(len(splines) - 1, -1, -1):
            if j != i:
                splines.remove(splines[j])
        
        new_objects.append(new_obj)

    #Clean up the original consolidated object
    bpy.data.objects.remove(obj, do_unlink=True)
    
    return new_objects

def boolean_operation(obj_a, obj_b, operation='DIFFERENCE'):
    """
    Performs a Boolean operation on obj_a with obj_b using the MANIFOLD solver.
    
    operation: 'UNION', 'INTERSECT', or 'DIFFERENCE'
    """
    # Ensure both objects exist
    if obj_a is None or obj_b is None:
        print("Error: One of the objects is None")
        return None

    # Add Boolean modifier to obj_a
    mod = obj_a.modifiers.new(name="BooleanManifold", type='BOOLEAN')
    mod.object = obj_b
    mod.operation = operation
    mod.solver = 'MANIFOLD'

    # Apply the modifier — obj_b must be viewport-visible or Blender refuses to apply
    prev_hide = obj_b.hide_viewport
    obj_b.hide_viewport = False
    bpy.context.view_layer.objects.active = obj_a
    bpy.ops.object.modifier_apply(modifier=mod.name)
    obj_b.hide_viewport = prev_hide

    return obj_a


def remove_objects(objects):
    """
    Remove a single object or a list of objects efficiently (script-friendly).
    """
    if not objects:
        return

    # Ensure it's always a list
    if not isinstance(objects, (list, tuple)):
        objects = [objects]

    for obj in objects:
        if obj is None:
            continue
        # Unlink from all collections
        for col in obj.users_collection:
            col.objects.unlink(obj)
        # Remove the object datablock
        bpy.data.objects.remove(obj)

def writeMetadata(obj, type = "MAP"):


    if type == "MAP":
        obj["Object type"] = type
        obj["Addon"] = bl_info["name"]
        obj["Version"] = bl_info["version"]

        obj["Generation Duration"] = str( bpy.context.scene.tp3d.sRunDuration) + " seconds"
        obj["Shape"] = bpy.context.scene.tp3d.shape
        obj["Resolution"] = bpy.context.scene.tp3d.num_subdivisions
        obj["Elevation Scale"] = bpy.context.scene.tp3d.scaleElevation
        obj["objSize"] = bpy.context.scene.tp3d.objSize
        obj["pathThickness"] = round(bpy.context.scene.tp3d.pathThickness,2)
        obj["overwritePathElevation"] = bpy.context.scene.tp3d.overwritePathElevation
        obj["api"] = bpy.context.scene.tp3d.api
        obj["scalemode"] = bpy.context.scene.tp3d.scalemode
        obj["fixedElevationScale"] = bpy.context.scene.tp3d.fixedElevationScale
        obj["minThickness"] = bpy.context.scene.tp3d.minThickness
        obj["xTerrainOffset"] = bpy.context.scene.tp3d.xTerrainOffset
        obj["yTerrainOffset"] = bpy.context.scene.tp3d.yTerrainOffset
        obj["singleColorMode"] = bpy.context.scene.tp3d.singleColorMode
        obj["selfHosted"] = bpy.context.scene.tp3d.selfHosted
        obj["Horizontal Scale"] = round(bpy.context.scene.tp3d.sScaleHor,6)
        obj["Generate Water"] = bpy.context.scene.tp3d.col_wActive
        obj["MinWaterSize"] = bpy.context.scene.tp3d.col_wArea
        obj["Keep Non-Manifold"] = bpy.context.scene.tp3d.col_KeepManifold
        obj["Map Size in Km"] = round(bpy.context.scene.tp3d.sMapInKm,2)
        obj["Dovetail"] = False
        obj["MagnetHoles"] = False
        obj["BottomMark"] = False
        obj["AdditionalExtrusion"] = bpy.context.scene.tp3d.sAdditionalExtrusion
        obj["lowestZ"] = bpy.context.scene.tp3d.lowestZ
        obj["highestZ"] = bpy.context.scene.tp3d.highestZ
        obj["dataset"] = bpy.context.scene.tp3d.dataset
        obj["name"] = bpy.context.scene.tp3d.name
        obj["pathScale"] = bpy.context.scene.tp3d.pathScale
        obj["scaleLon1"] = bpy.context.scene.tp3d.scaleLon1
        obj["scaleLat1"] = bpy.context.scene.tp3d.scaleLat1
        obj["scaleLon2"] = bpy.context.scene.tp3d.scaleLon2
        obj["scaleLat2"] = bpy.context.scene.tp3d.scaleLat2

        obj["shapeRotation"] = bpy.context.scene.tp3d.shapeRotation
        obj["pathVertices"] = bpy.context.scene.tp3d.o_verticesPath
        obj["mapVertices"] = bpy.context.scene.tp3d.o_verticesMap
        obj["mapScale"] = bpy.context.scene.tp3d.o_mapScale
        obj["centerx"] = bpy.context.scene.tp3d.o_centerx
        obj["centery"] = bpy.context.scene.tp3d.o_centery
        obj["latitude"], obj["longitude"] = convert_to_geo(bpy.context.scene.tp3d.o_centerx,bpy.context.scene.tp3d.o_centery)
        _scale_elev = bpy.context.scene.tp3d.scaleElevation
        _auto_scale = bpy.context.scene.tp3d.sAutoScale
        if _scale_elev != 0 and _auto_scale != 0:
            obj["Elevation Range (m)"] = round((bpy.context.scene.tp3d.highestZ - bpy.context.scene.tp3d.lowestZ) * 1000 / _scale_elev / _auto_scale, 1)
        else:
            obj["Elevation Range (m)"] = 0
        obj["sMapInKm"] = bpy.context.scene.tp3d.sMapInKm

        obj["col_wActive"] = bpy.context.scene.tp3d.col_wActive
        obj["col_wArea"] = bpy.context.scene.tp3d.col_wArea
        obj["col_fActive"] = bpy.context.scene.tp3d.col_fActive
        obj["col_fArea"] = bpy.context.scene.tp3d.col_fArea
        obj["col_cActive"] = bpy.context.scene.tp3d.col_cActive
        obj["col_cArea"] = bpy.context.scene.tp3d.col_cArea
        obj["col_glActive"] = bpy.context.scene.tp3d.col_glActive
        obj["col_glArea"] = bpy.context.scene.tp3d.col_glArea
        obj["col_scrActive"] = bpy.context.scene.tp3d.col_scrActive
        obj["col_scrArea"] = bpy.context.scene.tp3d.col_scrArea
        obj["col_faActive"] = bpy.context.scene.tp3d.col_faActive
        obj["col_faArea"] = bpy.context.scene.tp3d.col_faArea

        obj["el_bActive"] = bpy.context.scene.tp3d.el_bActive
        obj["el_sActive"] = bpy.context.scene.tp3d.el_sActive
        obj["el_sMultiplier"] = bpy.context.scene.tp3d.el_sMultiplier
        obj["el_oActive"] = bpy.context.scene.tp3d.el_oActive
        obj["el_oFlip"] = bpy.context.scene.tp3d.el_oFlip

        obj["elementMode"] = bpy.context.scene.tp3d.elementMode
        obj["singleColorModeElements"] = bpy.context.scene.tp3d.singleColorModeElements
        obj["tolerance"] = bpy.context.scene.tp3d.tolerance
        obj["toleranceElements"] = bpy.context.scene.tp3d.toleranceElements

        obj["ellipseRatio"] = bpy.context.scene.tp3d.ellipseRatio
        obj["rectangleHeight"] = bpy.context.scene.tp3d.rectangleHeight
        obj["indipendendTiles"] = bpy.context.scene.tp3d.indipendendTiles
        obj["tileSpacing"] = bpy.context.scene.tp3d.tileSpacing

        obj["generation_mode"] = bpy.context.scene.tp3d.generation_mode
        obj["mapmode"] = bpy.context.scene.tp3d.mapmode
        obj["jMapLat"] = bpy.context.scene.tp3d.jMapLat
        obj["jMapLon"] = bpy.context.scene.tp3d.jMapLon
        obj["jMapRadius"] = bpy.context.scene.tp3d.jMapRadius
        obj["jMapLat1"] = bpy.context.scene.tp3d.jMapLat1
        obj["jMapLat2"] = bpy.context.scene.tp3d.jMapLat2
        obj["jMapLon1"] = bpy.context.scene.tp3d.jMapLon1
        obj["jMapLon2"] = bpy.context.scene.tp3d.jMapLon2

        obj["openTopographyDataset"] = bpy.context.scene.tp3d.openTopographyDataset
        obj["disableCache"] = bpy.context.scene.tp3d.disableCache
        obj["ccacheSize"] = bpy.context.scene.tp3d.ccacheSize
        obj["apiRetries"] = bpy.context.scene.tp3d.apiRetries

        obj["disable_auto_export"] = bpy.context.scene.tp3d.disable_auto_export
        obj["disable_3mf_export"] = bpy.context.scene.tp3d.disable_3mf_export

        obj["ExportGroup"] = 1

        '''
        About ExportGroups
        0 = Printed Separate without Group
        1 = Printed with Map
        2 = Printed with Plate 
        '''



    if type =="TRAIL":
        obj["Object type"] = type
        obj["Addon"] = bl_info["name"]
        obj["Version"] = bl_info["version"]
        obj["xTerrainOffset"] = bpy.context.scene.tp3d.xTerrainOffset
        obj["yTerrainOffset"] = bpy.context.scene.tp3d.yTerrainOffset
        obj["singleColorModeTrail"] = bpy.context.scene.tp3d.singleColorMode

        obj["overwritePathElevation"] = bpy.context.scene.tp3d.overwritePathElevation

        obj["ExportGroup"] = 0 if bpy.context.scene.tp3d.singleColorMode else 1
    
    if type == "CITY" or type == "WATER" or type == "FOREST" or type == "GLACIER" or type == "FARMLAND" or type == "SCREE":
        obj["Object type"] = type
        obj["Addon"] = bl_info["name"]
        obj["Version"] = bl_info["version"]
        obj["minThickness"] = bpy.context.scene.tp3d.minThickness
        obj["xTerrainOffset"] = bpy.context.scene.tp3d.xTerrainOffset
        obj["yTerrainOffset"] = bpy.context.scene.tp3d.yTerrainOffset
        obj["elementMode"] = bpy.context.scene.tp3d.elementMode

        obj["ExportGroup"] = 0 if bpy.context.scene.tp3d.elementMode == "SINGLECOLORMODE" else 1
    
    if type == "BUILDINGS" or type == "STREET":

        obj["Object type"] = type
        obj["Addon"] = bl_info["name"]
        obj["Version"] = bl_info["version"]
        obj["minThickness"] = bpy.context.scene.tp3d.minThickness
        obj["xTerrainOffset"] = bpy.context.scene.tp3d.xTerrainOffset
        obj["yTerrainOffset"] = bpy.context.scene.tp3d.yTerrainOffset
        obj["elementMode"] = bpy.context.scene.tp3d.elementMode

        obj["ExportGroup"] = 1

    if type == "PLATE":
        obj["Object type"] = type
        obj["Addon"] = bl_info["name"]
        obj["Version"] = bl_info["version"]
        obj["Shape"] = bpy.context.scene.tp3d.shape
        obj["textFont"] = bpy.context.scene.tp3d.textFont
        obj["textSize"] = bpy.context.scene.tp3d.textSize
        obj["text1"] = bpy.context.scene.tp3d.textfield1
        obj["text2"] = bpy.context.scene.tp3d.textfield2
        obj["text3"] = bpy.context.scene.tp3d.textfield3
        obj["outerBorderSize"] = bpy.context.scene.tp3d.outerBorderSize
        obj["shapeRotation"] = bpy.context.scene.tp3d.shapeRotation
        obj["name"] = bpy.context.scene.tp3d.name
        obj["plateThickness"] = bpy.context.scene.tp3d.plateThickness
        obj["plateInsertValue"] = bpy.context.scene.tp3d.plateInsertValue
        obj["textAngle"] = bpy.context.scene.tp3d.text_angle_preset
        obj["objSize"] = bpy.context.scene.tp3d.objSize * ((100 + bpy.context.scene.tp3d.outerBorderSize)/100)
        obj["MagnetHoles"] = False
        obj["Dovetail"] = False
        obj["xTerrainOffset"] = bpy.context.scene.tp3d.xTerrainOffset
        obj["yTerrainOffset"] = bpy.context.scene.tp3d.yTerrainOffset

        obj["ExportGroup"] = 2 if bpy.context.scene.tp3d.plateInsertValue > 0 else 1
    
    if type == "TEXT":
        obj["Object type"] = type
        obj["Addon"] = bl_info["name"]
        obj["Version"] = bl_info["version"]
        obj["Shape"] = bpy.context.scene.tp3d.shape
        obj["textFont"] = bpy.context.scene.tp3d.textFont
        obj["textSize"] = bpy.context.scene.tp3d.textSize
        obj["text1"] = bpy.context.scene.tp3d.textfield1
        obj["text2"] = bpy.context.scene.tp3d.textfield2
        obj["text3"] = bpy.context.scene.tp3d.textfield3
        obj["outerBorderSize"] = bpy.context.scene.tp3d.outerBorderSize
        obj["shapeRotation"] = bpy.context.scene.tp3d.shapeRotation
        obj["name"] = bpy.context.scene.tp3d.name
        obj["plateThickness"] = bpy.context.scene.tp3d.plateThickness
        obj["plateInsertValue"] = bpy.context.scene.tp3d.plateInsertValue
        obj["textAngle"] = bpy.context.scene.tp3d.text_angle_preset
        obj["objSize"] = bpy.context.scene.tp3d.objSize * ((100 + bpy.context.scene.tp3d.outerBorderSize)/100)
        obj["MagnetHoles"] = False
        obj["Dovetail"] = False
        obj["xTerrainOffset"] = bpy.context.scene.tp3d.xTerrainOffset
        obj["yTerrainOffset"] = bpy.context.scene.tp3d.yTerrainOffset

        obj["ExportGroup"] = 2 if bpy.context.scene.tp3d.plateInsertValue > 0 else 1
    
    if type == "LINES":
        obj["Object type"] = type
        obj["cl_thickness"] = bpy.context.scene.tp3d.cl_thickness
        obj["cl_distance"] = bpy.context.scene.tp3d.cl_distance
        obj["cl_offset"] = bpy.context.scene.tp3d.cl_offset
        obj["xTerrainOffset"] = bpy.context.scene.tp3d.xTerrainOffset
        obj["yTerrainOffset"] = bpy.context.scene.tp3d.yTerrainOffset

        obj["ExportGroup"] = 1 #Print the lines with the Map

    if type == "OTHER":
        obj["Object type"] = type

    
def getHighestLowest(obj):

    # Get the bounding box corners in world space
    world_matrix = obj.matrix_world
    corners = [world_matrix @ Vector(corner) for corner in obj.bound_box]

    # Extract the Z values
    z_values = [c.z for c in corners]

    highest_z = max(z_values)
    lowest_z = min(z_values)

    return lowest_z, highest_z

def show_message_box(message, ic = "ERROR", ti = "ERROR"):
    def draw(self, context):
        self.layout.label(text=message)
    print(message)
    bpy.context.window_manager.popup_menu(draw, title=ti, icon=ic)


def toggle_console():
    try:
        if platform.system() == "Windows":
            bpy.ops.wm.console_toggle()
    except Exception as e:
        print(f"Could not toggle console: {e}")

def projection(operation, Mapobject, obj):

    if operation == "paint":
        merge_with_map(Mapobject, obj)

        obj.location.z += 1

        bpy.ops.object.origin_set(type='ORIGIN_CURSOR', center='MEDIAN')
        color_map_faces_by_terrain(Mapobject, obj)
        mesh_data = obj.data
        bpy.data.objects.remove(obj, do_unlink=True)
        bpy.data.meshes.remove(mesh_data)

    if operation == "separate":
        merge_with_map(Mapobject, obj)

        obj.data.materials.clear()

        obj.location.z += 0.2


    if operation == "singleColorMode":
        
        merge_with_map(Mapobject, obj,True)

        obj.data.materials.clear()


        thickerObj = single_color_mode_mesh(obj,Mapobject)

        remove_objects(thickerObj)

    if operation == "negative":
        merge_with_map(Mapobject, obj,True)
        boolean_operation(Mapobject,obj,"DIFFERENCE")
        remove_objects(obj)

def delete_selected_verts(obj):
    # Must be in Edit Mode
    if obj.mode != 'EDIT':
        bpy.ops.object.mode_set(mode='EDIT')

    # Get the BMesh representation
    me = obj.data
    bm = bmesh.from_edit_mesh(me)

    # Gather selected vertices
    verts_to_delete = [v for v in bm.verts if v.select]

    # Use bmesh.ops to delete them
    # context='VERTS' also deletes connected edges and faces
    bmesh.ops.delete(bm, geom=verts_to_delete, context='VERTS')

    # Update the mesh and viewport
    bmesh.update_edit_mesh(me)

    
def importSVGtoMerge(Mapobject):


    svg_path = bpy.context.scene.tp3d.svg_path
    #svg_path = "C:/Users/marti/Downloads/arrow-down-left-svgrepo-com.svg"
    extrude_depth = 0.01
    scale_factor = 100.0

    # -----------------------
    # 1. Import SVG
    # -----------------------

    # Objects before import
    before = set(bpy.data.objects)
    before_collections = set(bpy.data.collections)

    bpy.ops.import_curve.svg(filepath=svg_path)

    # Objects after import
    after = set(bpy.data.objects)

    # Move SVG objects from the auto-created collection to Scene Collection and remove it
    scene_col = bpy.context.scene.collection
    for new_col in set(bpy.data.collections) - before_collections:
        for obj in list(new_col.all_objects):
            if not scene_col.objects.get(obj.name):
                scene_col.objects.link(obj)
        bpy.data.collections.remove(new_col, do_unlink=True)

    # Newly created objects
    svg_objs = [obj for obj in after - before if obj.type == 'CURVE']



    for obj in svg_objs:
        curve = obj.data
        
        # Curve setup (preserve holes)
        curve.dimensions = '2D'
        curve.fill_mode = 'BOTH'
        curve.use_fill_caps = True

        curve.bevel_depth = 0
        curve.bevel_resolution = 0

        curve.extrude = extrude_depth
        
        
        # Scale SVG
        obj.scale *= scale_factor


        # Convert to mesh
        bpy.ops.object.select_all(action='DESELECT')
        
        obj.select_set(True)
        bpy.context.view_layer.objects.active = obj
        
        bpy.ops.object.convert(target='MESH')

        bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)


        bpy.ops.object.mode_set(mode='EDIT')

        bpy.ops.mesh.select_all(action='SELECT')
        bpy.ops.mesh.remove_doubles(threshold=0.0001)  # Works in all 2.8+ versions

        bpy.ops.object.mode_set(mode='OBJECT')
    
    bpy.ops.object.select_all(action='DESELECT')
    #for obj in svg_objs:
    svg = merge_objects(svg_objs)

    svg.select_set(True)
    bpy.context.view_layer.objects.active = svg

    bpy.ops.object.origin_set(
        type='ORIGIN_GEOMETRY',
        center='BOUNDS'
    )

    # Move object so origin is at world center
    svg.location = bpy.context.scene.cursor.location

    return svg
        
def read_gpx_and_create_heightmap(length=100.0, height=20.0):

    # Get file path
    gpx_file_path = bpy.context.scene.tp3d.get('file_path', None)
    if not gpx_file_path or not os.path.exists(gpx_file_path):
        print("Invalid or missing GPX file path.")
        return

    points = []
    total_distance = 0.0
    max_elevation = float('-inf')
    min_elevation = float('inf')
    prev_point = None

    separate_paths = read_gpx_file()
    temppoints = [item for sublist in separate_paths for item in sublist]

    for i, pnt in enumerate(temppoints):
        lat = pnt[0]
        lon = pnt[1]
        ele = pnt[2]
        elevation = ele if ele is not None else 0.0
        if prev_point:
            dist = haversine(prev_point[0], prev_point[1], lat, lon)
            total_distance += dist

        points.append((lat, lon, elevation, total_distance))
        max_elevation = max(max_elevation, elevation)
        min_elevation = min(min_elevation, elevation)
        prev_point = (lat, lon)

    if total_distance == 0 or not points:
        print("No valid points or zero-length route.")
        return

    # Create a 2D surface (closed shape)
    curve_data = bpy.data.curves.new(name='RouteProfile', type='CURVE')
    curve_data.dimensions = '2D'
    curve_data.fill_mode = 'BOTH'
    spline = curve_data.splines.new('POLY')
    spline.use_cyclic_u = True  # Close the shape

    # Add original points as elevation profile
    profile_points = []

    print(f"Min elevation: {min_elevation}")

    for lat, lon, elevation, distance in points:
        x = (distance / total_distance) * length - length/2
        y = ((elevation-min_elevation) / (max_elevation-min_elevation)) * (height-2) + 2
        profile_points.append((x, y))

    # Add bottom-left and bottom-right points to close the shape
    bottom_left = (profile_points[0][0], -0.0)
    bottom_right = (profile_points[-1][0], -0.0)

    full_points = profile_points + [bottom_right, bottom_left]

    spline.points.add(len(full_points) - 1)

    for i, (x, y) in enumerate(full_points):
        spline.points[i].co = (x, y, 0.0, 1.0)

    # Create and link the object
    curve_obj = bpy.data.objects.new("RouteProfileSurface", curve_data)
    bpy.context.collection.objects.link(curve_obj)

    # Convert to mesh and extrude
    bpy.context.view_layer.objects.active = curve_obj
    curve_obj.select_set(True)
    bpy.ops.object.convert(target='MESH')

    mesh_obj = bpy.context.object
    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.mesh.extrude_region_move(TRANSFORM_OT_translate={"value": (0, 0, 1)})
    bpy.ops.object.editmode_toggle()

    print(f"Route length: {total_distance:.2f} meters")
    print(f"Maximum elevation: {max_elevation:.2f} meters")
    
    curve_obj.location = bpy.context.scene.cursor.location

    return curve_obj


# ---------------------------------------------------------------------------
# runGeneration sub-phase helpers
# ---------------------------------------------------------------------------

def _rg_validate_inputs(flags):
    """Load all scene properties, validate inputs, and open the console.

    Returns a props dict on success, or None if validation fails (console
    is toggled closed before returning None).
    """
    if bpy.app.version < const.required_blender_version:
        show_message_box(
            f"TrailPrint3D requires Blender "
            f"{const.required_blender_version[0]}.{const.required_blender_version[1]}"
            f" or higher. (you are using {bpy.app.version_string}).  "
        )
        return None

    start_time = time.time()
    for i in range(30):
        print(" ")
    print("------------------------------------------------")
    print("SCRIPT STARTED - DO NOT CLOSE THIS WINDOW")
    print("------------------------------------------------")
    print(" ")

    tp3d = bpy.context.scene.tp3d
    gpx_file_path      = tp3d.get('file_path', None)
    gpx_chain_path     = tp3d.get('chain_path', None)
    exportPath         = tp3d.get('export_path', None)
    shape              = tp3d.shape
    name               = tp3d.get('trailName', "")
    size               = tp3d.get('objSize', 100)
    scaleElevation     = tp3d.get('scaleElevation', 10)
    scalemode          = tp3d.scalemode
    scaleLon1          = tp3d.get('scaleLon1', 0)
    scaleLat1          = tp3d.get('scaleLat1', 0)
    scaleLon2          = tp3d.get('scaleLon2', 0)
    scaleLat2          = tp3d.get('scaleLat2', 0)
    shapeRotation      = tp3d.get('shapeRotation', 0)
    overwritePathElev  = tp3d.get('overwritePathElevation', True)
    api                = tp3d.api
    selfHosted         = tp3d.get("selfHosted", "")
    fixedElevScale     = tp3d.get('fixedElevationScale', False)
    minThickness       = tp3d.get("minThickness", 2)
    xTerrainOffset     = tp3d.get("xTerrainOffset", 0)
    yTerrainOffset     = tp3d.get("yTerrainOffset", 0)
    singleColorMode    = tp3d.get("singleColorMode", 0)
    elementMode        = tp3d.elementMode
    disableCache       = tp3d.get("disableCache", 0)
    num_subdivisions   = tp3d.num_subdivisions
    textFont           = tp3d.get("textFont", "")
    plateThickness     = tp3d.get("plateThickness", 5)
    col_wActive        = tp3d.col_wActive
    col_fActive        = tp3d.col_fActive
    col_cActive        = tp3d.col_cActive
    col_glActive       = tp3d.col_glActive
    el_bActive         = tp3d.el_bActive
    el_sActive         = tp3d.el_sActive
    jMapLat            = tp3d.get("jMapLat", 49)
    jMapLon            = tp3d.get("jMapLon", 9)
    jMapRadius         = tp3d.get("jMapRadius", 50)
    jMapLat1           = tp3d.get("jMapLat1", 48)
    jMapLon1           = tp3d.get("jMapLon1", 8)
    jMapLat2           = tp3d.get("jMapLat2", 49)
    jMapLon2           = tp3d.get("jMapLon2", 9)

    opentopoAdress = "https://api.opentopodata.org/v1/"
    if selfHosted != "" and selfHosted is not None and api == "OPENTOPODATA":
        opentopoAdress = selfHosted
        print(f"!!using {opentopoAdress} instead of Opentopodata!!")
    tp3d.opentopoAdress = opentopoAdress

    # --- Input validation ---
    from .addon_preferences import get_prefs
    _ot_api_key = get_prefs().openTopographyApiKey
    if api == "OPENTOPOGRAPHY" and not _ot_api_key:
        print("No OPENTOPOGRAPHY API key entered")
        show_message_box(
            "OpenTopography requires an API key. "
            "Get a free key at portal.opentopography.org and set it in the addon preferences."
        )
        return None

    if "gpx_file" in flags:
        if not gpx_file_path or gpx_file_path == "":
            show_message_box("File path is empty! Please select a valid file.")
            return None
        if not os.path.isfile(gpx_file_path):
            show_message_box(f"Invalid file path: {gpx_file_path}. Please select a valid file.")
            return None
        gpx_file_path = bpy.path.abspath(gpx_file_path)
        file_extension = os.path.splitext(gpx_file_path)[1].lower()
        if file_extension != '.gpx' and file_extension != ".igc":
            show_message_box(f"Invalid file format. Please Use a .GPX file")
            return None
    if "gpx_chain" in flags:
        if not gpx_chain_path or gpx_chain_path == "":
            show_message_box("CHAIN path is empty! Please select a valid folder.")
            return None
        gpx_chain_path = bpy.path.abspath(gpx_chain_path)
    if not exportPath:
        exportPath = addon_preferences.get_prefs().default_export_folder
    if not exportPath:
        show_message_box("Export path cant be empty")
        return None
    exportPath = bpy.path.abspath(exportPath)
    if not exportPath or exportPath == "":
        show_message_box("Export path is empty! Please select a valid folder.")
        return None
    if not os.path.isdir(exportPath):
        show_message_box(f"Invalid export Directory: {exportPath}. Please select a valid Directory.")
        return None

    # --- Default font ---
    if textFont == "":
        if platform.system() == "Windows":
            textFont = "C:/WINDOWS/FONTS/ariblk.ttf"
        elif platform.system() == "Darwin":
            textFont = "/System/Library/Fonts/Supplemental/Arial Black.ttf"
        else:
            textFont = ""

    # --- Default model name from file/folder ---
    if name == "":
        if "gpx_file" in flags:
            name_with_ext = os.path.basename(gpx_file_path)
            name = os.path.splitext(name_with_ext)[0]
        if "gpx_chain" in flags and "append_collection" not in flags:
            name_with_ext = os.path.basename(os.path.normpath(gpx_chain_path))
            name = os.path.splitext(name_with_ext)[0]
        if "gpx_file" not in flags and "gpx_chain" not in flags:
            name = "Terrain"

    modelname = name
    tp3d.modelname = modelname

    return {
        'start_time':            start_time,
        'gpx_file_path':         gpx_file_path,
        'gpx_chain_path':        gpx_chain_path,
        'exportPath':            exportPath,
        'shape':                 shape,
        'name':                  name,
        'modelname':             modelname,
        'size':                  size,
        'scaleElevation':        scaleElevation,
        'scalemode':             scalemode,
        'scaleLon1':             scaleLon1,
        'scaleLat1':             scaleLat1,
        'scaleLon2':             scaleLon2,
        'scaleLat2':             scaleLat2,
        'shapeRotation':         shapeRotation,
        'overwritePathElevation': overwritePathElev,
        'api':                   api,
        'selfHosted':            selfHosted,
        'fixedElevationScale':   fixedElevScale,
        'minThickness':          minThickness,
        'xTerrainOffset':        xTerrainOffset,
        'yTerrainOffset':        yTerrainOffset,
        'singleColorMode':       singleColorMode,
        'elementMode':           elementMode,
        'disableCache':          disableCache,
        'num_subdivisions':      num_subdivisions,
        'textFont':              textFont,
        'plateThickness':        plateThickness,
        'col_wActive':           col_wActive,
        'col_fActive':           col_fActive,
        'col_cActive':           col_cActive,
        'col_glActive':          col_glActive,
        'el_bActive':            el_bActive,
        'el_sActive':            el_sActive,
        'jMapLat':               jMapLat,
        'jMapLon':               jMapLon,
        'jMapRadius':            jMapRadius,
        'jMapLat1':              jMapLat1,
        'jMapLon1':              jMapLon1,
        'jMapLat2':              jMapLat2,
        'jMapLon2':              jMapLon2,
    }


def _rg_load_coordinates(flags, props):
    """Load GPX / synthetic coordinate data based on generation type.

    Returns (coordinates, separate_paths, coordinates2) or None on error.
    """
    setupColors()

    if props['disableCache'] == 1:
        print("INFO: Cache Disabled (in Advanced Settings)")
    if not props['overwritePathElevation'] and not props['singleColorMode']:
        print("INFO: Overwrite Path Elevation disabled: Path Elevation wont be Adjusted to Map elevation")
    if "gpx_file" in flags or ("gpx_chain" in flags and "append_collection" not in flags):
        if props['xTerrainOffset'] > 0:
            print(f"INFO: Map will be moved in X by {props['xTerrainOffset']} (Advanced Settings -> Map -> xTerrainOffset)")
        if props['yTerrainOffset'] > 0:
            print(f"INFO: Map will be moved in Y by {props['yTerrainOffset']} (Advanced Settings -> Map -> yTerrainOffset)")

    if bpy.context.object and bpy.context.object.mode == 'EDIT':
        bpy.ops.object.mode_set(mode='OBJECT')
    bpy.context.scene.tool_settings.use_mesh_automerge = False

    coordinates2 = []
    separate_paths = []
    separate_paths_by_file = []  # segments grouped by source file (gpx_chain only)
    try:
        if "gpx_file" in flags and "trail_map" not in flags:
            separate_paths = read_gpx_file()
        if "gpx_chain" in flags not in flags:
            separate_paths_by_file = read_gpx_directory(props['gpx_chain_path'])
            separate_paths = [seg for file_segs in separate_paths_by_file for seg in file_segs]
        if "jmap" in flags:
            nlat, nlon = move_coordinates(props['jMapLat'], props['jMapLon'], props['jMapRadius'], "e")
            separate_paths.append([(nlat, nlon, 0, 0)])
            nlat, nlon = move_coordinates(props['jMapLat'], props['jMapLon'], props['jMapRadius'], "s")
            separate_paths.append([(nlat, nlon, 0, 0)])
            nlat, nlon = move_coordinates(props['jMapLat'], props['jMapLon'], props['jMapRadius'], "w")
            separate_paths.append([(nlat, nlon, 0, 0)])
            nlat, nlon = move_coordinates(props['jMapLat'], props['jMapLon'], props['jMapRadius'], "n")
            separate_paths.append([(nlat, nlon, 0, 0)])
            if "trail_map" in flags:
                tempcoordinates = read_gpx_file()
                coordinates2 = [item for sublist in tempcoordinates for item in sublist]
        if "jmap_bbox" in flags:
            separate_paths.append([(props['jMapLat1'], props['jMapLon1'], 0, 0)])
            separate_paths.append([(props['jMapLat2'], props['jMapLon2'], 0, 0)])
    except Exception as e:
        #show_message_box(f"Something went Wrong reading the GPX. Type {type}")
        _progress.WarningsOverlay.add_warning("Something went Wrong reading the GPX file", "error")
        return None

    coordinates = [item for sublist in separate_paths for item in sublist]

    return (coordinates, separate_paths, coordinates2, separate_paths_by_file)


def _rg_compute_trail_stats(flags, coordinates):
    """Calculate trail statistics and store them in scene properties."""
    total_length = 0
    total_elevation = 0
    total_time = 0
    average_speed = 0
    trail_date = ""
    if "stats" in flags:
        total_length    = calculate_total_length(coordinates)
        total_elevation = calculate_total_elevation(coordinates)
        total_time      = calculate_total_time(coordinates)
        trail_date      = calculate_date(coordinates)
        if total_time is not None and total_time > 0:
            average_speed = total_length / total_time

    hours = int(total_time)
    minutes = int((total_time - hours) * 60)
    time_str = f"{hours}h {minutes}m"
    #print(f"Total elevation: {total_elevation}")

    tp3d = bpy.context.scene.tp3d
    tp3d.sTime_str      = time_str
    tp3d.total_length   = total_length
    tp3d.total_elevation = total_elevation
    tp3d.total_time     = total_time
    tp3d.average_speed  = average_speed
    #print(f"Traildate:{trail_date}")
    tp3d.trail_date     = trail_date


def _rg_create_map_object(flags, props, modelname, centerx, centery):
    """Create, rotate, and position the base map shape object."""
    shape          = props['shape']
    size           = props['size']
    num_subdivisions = props['num_subdivisions']
    shapeRotation  = props['shapeRotation']
    scalemode      = props['scalemode']
    xTerrainOffset = props['xTerrainOffset']
    yTerrainOffset = props['yTerrainOffset']

    if "append_collection" not in flags and "use_active_object" not in flags:
        if shape == "SQUARE":
            rHeight = bpy.context.scene.tp3d.rectangleHeight
            MapObject = create_rectangle(size, rHeight, num_subdivisions, modelname)
        elif shape in {"HEXAGON", "HEXAGON INNER TEXT", "HEXAGON OUTER TEXT", "HEXAGON FRONT TEXT"}:
            MapObject = create_hexagon(size / 2, num_subdivisions, modelname)
        elif shape == "HEART":
            MapObject = create_heart(size / 2, num_subdivisions, modelname)
        elif shape in {"OCTAGON", "OCTAGON OUTER TEXT"}:
            MapObject = create_octagon(size / 2, num_subdivisions, modelname)
        elif shape in {"CIRCLE", "MEDAL"}:
            MapObject = create_circle(size / 2, num_subdivisions, modelname)
        elif shape == "ELLIPSE":
            ratio = bpy.context.scene.tp3d.ellipseRatio
            MapObject = create_ellipse(size / 2, num_subdivisions, modelname, ratio)
        else:
            MapObject = create_hexagon(size / 2, num_subdivisions, modelname)
    if "append_collection" in flags:
        print("APPENDING COLLECTION")
        appendCollection()
        MapObject = bpy.context.view_layer.objects.active
        MapObject.location = Vector((0,0,0))
    if "use_active_object" in flags:
        MapObject = bpy.context.view_layer.objects.active
        return MapObject

    recalculateNormals(MapObject)

    MapObject.rotation_euler[2] += shapeRotation * (3.14159265 / 180)
    MapObject.select_set(True)
    bpy.context.view_layer.objects.active = MapObject
    bpy.ops.object.transform_apply(location=False, rotation=True, scale=False)

    targetx = centerx + xTerrainOffset
    targety = centery + yTerrainOffset
    if scalemode == "COORDINATES" and "chain_coords_center" in flags:
        midLat, midLon = midpoint_spherical(props['scaleLat1'], props['scaleLon1'], props['scaleLat2'], props['scaleLon2'])
        targetx, targety, el = convert_to_blender_coordinates(midLat, midLon, 0, 0)

    transform_MapObject(MapObject, targetx, targety)
    return MapObject


def _rg_build_terrain_elements(obj, scaleHor, curveObj=None):
    """Create water, forest, city, glacier, building and road overlay meshes.

    Reads all flags directly from bpy.context.scene.tp3d.
    Returns a dict keyed by element name; values may be None if disabled.
    """
    tp3d   = bpy.context.scene.tp3d
    map_km = tp3d["sMapInKm"]
    _ov    = _progress.ProgressOverlay.get()

    # --------------------------------------------------
    # Standard coloring elements (all share the same pattern).
    # To add a new layer: append one tuple here and nothing else.
    #   (result_key, active_flag_attr, max_size_const, phase_label, fetch_message)
    # --------------------------------------------------
    COLORING_ELEMENTS = [
        ('water',   'col_wActive',   const.WATER_MAXSIZE,   "Water",   "Fetching water data…"),
        ('forest',  'col_fActive',   const.FOREST_MAXSIZE,  "Forest",  "Fetching forest data…"),
        ('scree',   'col_scrActive', const.SCREE_MAXSIZE,   "Scree",   "Fetching scree data…"),
        ('city',     'col_cActive',   const.CITY_MAXSIZE,     "City",     "Fetching city data…"),
        ('farmland', 'col_faActive',  const.FARMLAND_MAXSIZE, "Farmland", "Fetching farmland data…"),
        ('glacier',  'col_glActive',  const.GLACIER_MAXSIZE,  "Glacier",  "Fetching glacier data…"),
    ]

    # Count total active elements (coloring + optional ocean/buildings/roads) for progress spread
    _ELEM_PHASE_START = 0.83
    _ELEM_PHASE_END   = 0.95
    _active_elem_flags = (
        [flag for _, flag, size, _, _ in COLORING_ELEMENTS if getattr(tp3d, flag) == 1 and map_km <= size]
        + (['_ocean']    if tp3d.el_oActive == 1 else [])
        + (['_buildings'] if tp3d.el_bActive == 1 and map_km <= const.BUILDINGS_MAXSIZE else [])
        + (['_roads']    if tp3d.el_sActive == 1 and map_km <= const.ROADS_MAXSIZE else [])
    )
    _total_active = max(len(_active_elem_flags), 1)
    _elem_step = (_ELEM_PHASE_END - _ELEM_PHASE_START) / _total_active
    _elem_idx = [0]  # mutable counter

    def _advance_elem_progress(phase_label, msg):
        if _ov.active:
            pct = _ELEM_PHASE_START + _elem_idx[0] * _elem_step
            _ov.update(percent=pct, phase=phase_label, message=msg)
        _elem_idx[0] += 1

    terrain = {}
    for key, flag_attr, max_size, phase, msg in COLORING_ELEMENTS:
        terrain[key] = None
        if getattr(tp3d, flag_attr) == 1:
            if map_km <= max_size:
                _advance_elem_progress(phase, msg)
                terrain[key] = coloring_main(obj, key.upper())  #COLORING MAIN-----------------------------------------------------
            else:
                print(f"INFO: MAP IS TOO BIG FOR {key.upper()} (< {max_size} km required)")
                _progress.WarningsOverlay.add_warning(f"Map too big for {phase} layer.", "warn")
    # --------------------------------------------------
    # Ocean — unique creation logic, no size cap.
    # --------------------------------------------------
    terrain['ocean'] = None
    if tp3d.el_oActive == 1:
        _advance_elem_progress("Ocean", "Creating ocean…")
        minLat = tp3d.minLat
        minLon = tp3d.minLon
        maxLat = tp3d.maxLat
        maxLon = tp3d.maxLon
        if curveObj is not None:
            landpoints = get_random_world_vertices(curveObj, 200)
        else:
            print("No trail found, deriving land hints from terrain elevation")
            depsgraph = bpy.context.evaluated_depsgraph_get()
            obj_eval  = obj.evaluated_get(depsgraph)
            world_mat = obj_eval.matrix_world
            all_verts = [world_mat @ v.co for v in obj_eval.data.vertices]
            if all_verts:
                avg_z      = sum(v.z for v in all_verts) / len(all_verts)
                high_verts = [v for v in all_verts if v.z > avg_z]
                sample_pool = high_verts if high_verts else all_verts
                landpoints  = random.sample(sample_pool, min(200, len(sample_pool)))
            else:
                landpoints = []
        print("Create Ocean")
        ocean_pad_lat = (maxLat - minLat) * 0.10
        ocean_pad_lon = (maxLon - minLon) * 0.10
        terrain['ocean'] = createOcean(
            (minLat - ocean_pad_lat, minLon - ocean_pad_lon, maxLat + ocean_pad_lat, maxLon + ocean_pad_lon),
            2, scaleHor, landpoints, obj, obj, tp3d.minThickness,
        )

    print("Base elements Created")

    # --------------------------------------------------
    # Buildings — own creation function + intersection post-processing.
    # --------------------------------------------------
    terrain['buildings'] = None
    if tp3d.el_bActive == 1:
        if map_km <= const.BUILDINGS_MAXSIZE:
            _advance_elem_progress("Buildings", "Fetching building data…")
            buildings = create_buildings(obj, 10, scaleHor)
            set_origin_to_3d_cursor(buildings)
            intersectWithTile(obj, buildings)
            terrain['buildings'] = buildings
        else:
            print("INFO: MAP IS TOO BIG FOR BUILDINGS (< 10Km Map size Required)")
            _progress.WarningsOverlay.add_warning("Map too big for Buildings.", "warn")

    # --------------------------------------------------
    # Roads — own creation function + clipping + material post-processing.
    # --------------------------------------------------
    terrain['roads'] = None
    if tp3d.el_sActive == 1:
        if map_km <= const.ROADS_MAXSIZE:
            _advance_elem_progress("Roads", "Fetching road data…")
            roads = create_roads(obj, 20, scaleHor, map_km)
            set_origin_to_3d_cursor(roads)
            recalculateNormals(roads)
            boolean_operation(roads, obj, "INTERSECT")
            selectBottomFaces(roads)
            bpy.ops.transform.translate(value=(0, 0, -0.2), orient_type='GLOBAL')
            bpy.ops.object.mode_set(mode="OBJECT")
            roads.data.materials.clear()
            roads.data.materials.append(bpy.data.materials.get("BLACK"))
            terrain['roads'] = roads
        else:
            print("INFO: MAP IS TOO BIG FOR STREETS (< 100Km Map size Required)")
            _progress.WarningsOverlay.add_warning("Map too big for Roads.", "warn")

    return terrain


def _rg_apply_single_color_mode(obj, curveObjs, terrain, props):
    """Apply single-color-mode boolean projection between terrain layers and curves.

    Terrain elements are processed in priority order: each element subtracts
    thicker versions of all higher-priority elements that were already processed.
    To add a new terrain layer, append its key to TERRAIN_PRIORITY_ORDER and make
    sure it is populated in the terrain dict passed by the caller.
    """
    # Priority order: index 0 = highest priority (subtracted from everything below it).
    # Add new terrain keys here to include them automatically.
    TERRAIN_PRIORITY_ORDER = ['water', 'forest', 'scree', 'city', 'farmland', 'glacier', 'ocean']

    return

    thickerCurves = []
    if props['singleColorMode'] == 1:
        if curveObjs:
            dpt = 1
            dup = obj.copy()
            dup.data = obj.data.copy()
            dup.name = f"{obj.name}_dup_for_projection"
            if obj.users_collection:
                for coll in obj.users_collection:
                    coll.objects.link(dup)
            for tcrv in curveObjs:
                thickerCurves.append(single_color_mode_curve(tcrv, obj, True, dpt, dup))
            remove_objects(dup)
            for i in range(len(curveObjs) - 1):
                recalculateNormals(curveObjs[i + 1])
                recalculateNormals(thickerCurves[i])
                thickerCurves[i].scale = (1.01, 1.01, 1.01)
                boolean_operation(curveObjs[i + 1], thickerCurves[i])
    
    if props['elementMode'] == "SEPARATE":
        for i, key in enumerate(TERRAIN_PRIORITY_ORDER):
            elem_obj = terrain.get(key)
            if not elem_obj:
                continue
            if props['singleColorMode'] == 1:
                for tcrv in curveObjs:
                    boolean_operation(elem_obj, tcrv)

    if props['elementMode'] == "SINGLECOLORMODE":
        # Maps key -> thicker mesh object, filled as each element is processed.
        thicker_by_key = {}

        for i, key in enumerate(TERRAIN_PRIORITY_ORDER):
            elem_obj = terrain.get(key)
            if not elem_obj:
                continue

            thicker = single_color_mode_mesh(elem_obj, obj)
            thicker_by_key[key] = thicker

            # Subtract all curve thicker-bodies
            for tcrv in thickerCurves:
                boolean_operation(elem_obj, tcrv)

            # Subtract every higher-priority element that was already processed
            for prev_key in TERRAIN_PRIORITY_ORDER[:i]:
                if prev_key in thicker_by_key:
                    boolean_operation(elem_obj, thicker_by_key[prev_key])

        for thicker in thicker_by_key.values():
            pass
            #remove_objects(thicker)

    if thickerCurves:
        #print(f"Len curves: {len(thickerCurves)}")
        remove_objects(thickerCurves)
        #print(f"Len curves: {len(thickerCurves)}")


def _rg_assign_materials_and_export(obj, curveObjs, textobj, plateobj, props, buggyDataset, start_time, exportformat, terrain=None):
    """Assign trail/text materials, export all STL files, write metadata, and finalize."""

    if "shape" in props.keys():
        shape = props['shape']
    else:
        shape = None

    bpy.ops.object.select_all(action='DESELECT')

    # Embed metadata into scene objects
    writeMetadata(obj, "MAP")
    if curveObjs:
        for tcrv in curveObjs:
            writeMetadata(tcrv, "TRAIL")

    # Assign alternating TRAIL/YELLOW materials to trail curve segments
    if curveObjs:
        mats = "TRAIL"
        for tcrv in curveObjs:
            if tcrv and tcrv.name in bpy.data.objects:
                mat = bpy.data.materials.get(mats)
                tcrv.data.materials.clear()
                tcrv.data.materials.append(mat)
                mats = "YELLOW" if mats == "TRAIL" else "TRAIL"


    # Export all geometry
    tp3d_props = bpy.context.scene.tp3d
    if getattr(tp3d_props, 'disable_auto_export', False):
        print("Auto export disabled, skipping export")
        return

    if is_3mf_extension_installed() and not getattr(tp3d_props, 'disable_3mf_export', False):
        print("Exporting to 3mf")
        # Select all objects to export, then use the 3MF exporter
        if curveObjs:
            for tcrv in curveObjs:
                if tcrv and tcrv.name in bpy.data.objects:
                    tcrv.select_set(True)
        obj.select_set(True)

        # Terrain elements in SEPARATE mode: select for export
        if terrain and props.get('elementMode') == "SEPARATE" or props.get('elementMode') == "SINGLECOLORMODE":
            for elem_obj in terrain.values():
                if elem_obj and elem_obj.name in bpy.data.objects:
                    elem_obj.select_set(True)

        # Text object: material + select
        if shape in {"HEXAGON INNER TEXT", "HEXAGON OUTER TEXT", "OCTAGON OUTER TEXT", "HEXAGON FRONT TEXT", "MEDAL"}:
            mat_name = "TRAIL" if shape == "HEXAGON INNER TEXT" else "WHITE"
            mat = bpy.data.materials.get(mat_name)
            textobj.data.materials.clear()
            textobj.data.materials.append(mat)
            writeMetadata(textobj, type="TEXT")
            textobj.select_set(True)

        # Plate object: material + select
        if shape in {"HEXAGON OUTER TEXT", "OCTAGON OUTER TEXT", "HEXAGON FRONT TEXT", "MEDAL"}:
            mat = bpy.data.materials.get("BLACK")
            plateobj.data.materials.clear()
            plateobj.data.materials.append(mat)
            writeMetadata(plateobj, type="PLATE")
            plateobj.select_set(True)
        

        export_selected_to_3mf()
    else:
        print("exporting as STL/OBJ")
        if curveObjs:
            for tcrv in curveObjs:
                export_to_STL(tcrv, exportformat)
        export_to_STL(obj, exportformat)

        # Terrain elements in SEPARATE mode: export individually
        if terrain and props.get('elementMode') == "SEPARATE":
            for elem_obj in terrain.values():
                if elem_obj and elem_obj.name in bpy.data.objects:
                    export_to_STL(elem_obj, exportformat)

        # Text object: material + export
        if shape in {"HEXAGON INNER TEXT", "HEXAGON OUTER TEXT", "OCTAGON OUTER TEXT", "HEXAGON FRONT TEXT", "MEDAL"}:
            mat_name = "TRAIL" if shape == "HEXAGON INNER TEXT" else "WHITE"
            mat = bpy.data.materials.get(mat_name)
            textobj.data.materials.clear()
            textobj.data.materials.append(mat)
            writeMetadata(textobj, type="TEXT")
            export_to_STL(textobj, exportformat)

        # Plate object: material + export
        if shape in {"HEXAGON OUTER TEXT", "OCTAGON OUTER TEXT", "HEXAGON FRONT TEXT", "MEDAL"}:
            mat = bpy.data.materials.get("BLACK")
            plateobj.data.materials.clear()
            plateobj.data.materials.append(mat)
            writeMetadata(plateobj, type="PLATE")
            export_to_STL(plateobj, exportformat)

    # Script duration
    end_time = time.time()
    duration = end_time - start_time
    bpy.context.scene.tp3d["o_time"] = _("Script ran for {} seconds").format(round(duration))


    # API counter update
    count_openTopoData, _dt1, count_openElevation, _dt2 = load_counter()
    tp3d = bpy.context.scene.tp3d
    tp3d["o_apiCounter_OpenTopoData"] = (
        f"API Limit: {count_openTopoData:.0f}/1000 daily"
        if count_openTopoData < 1000
        else f"API Limit: {count_openTopoData:.0f}/1000 (daily limit reached. might cause problems)"
    )
    tp3d["o_apiCounter_OpenElevation"] = (
        f"API Limit: {count_openElevation:.0f}/1000 Monthly"
        if count_openElevation < 1000
        else f"API Limit: {count_openElevation:.0f}/1000 (Monthly limit reached. might cause problems)"
    )

    if buggyDataset != 0:
        #show_message_box(f"API seems to have faulty Data. Try diffrent Resolution or API")
        _progress.WarningsOverlay.add_warning("API might have faulty DATA. Maybe try diffrent Resolution or API", "warn")

    zoom_camera_to_selected(obj)

    #bpy.ops.object.select_all(action='DESELECT')
    
    print(f"Finished. Generating Map took {duration:.0f} seconds")
    print("----------------------------------------------------------------")
    print(f"")


# ---------------------------------------------------------------------------
# Generation feature flags
# Each type integer maps to a frozenset of capability strings used throughout
# the pipeline instead of scattered `if type == X` comparisons.
# ---------------------------------------------------------------------------

_GEN_FLAGS = {
    0:  frozenset({"gpx_file",  "trail", "stats", "gpx_scale"}),
    1:  frozenset({"gpx_chain", "trail", "stats", "gpx_scale", "separate_paths", "chain_coords_center"}),
    2:  frozenset({"jmap"}),
    3:  frozenset({"jmap_bbox", "trail"}),
    4:  frozenset({"gpx_file",  "jmap",  "trail", "trail_map"}),
    10: frozenset({"gpx_file", "stats", "gpx_scale"}),
    11: frozenset({"gpx_chain", "stats", "gpx_scale", "separate_path", "chain_coords_center"}),
    20: frozenset({"gpx_file", "trail", "stats", "gpx_scale","append_collection"}),
    21: frozenset({"gpx_chain", "trail", "stats", "gpx_scale", "separate_paths", "chain_coords_center","append_collection"}),
}

# ---------------------------------------------------------------------------
# Main generation orchestrator
# ---------------------------------------------------------------------------

def runGeneration(type):

    """Orchestrate the full 3D map generation pipeline."""

    flags = _GEN_FLAGS[type]

    overlay = _progress.ProgressOverlay.get()
    overlay.start()
    _progress.WarningsOverlay.clear()

    # --- Phase 1: Validate inputs and load all scene settings ---
    overlay.update(0.03, "Initializing", "Validating inputs…")
    props = _rg_validate_inputs(flags)
    if props is None:
        overlay.finish()
        return
    start_time = props['start_time']
    buggyDataset = 0
    exportformat = "STL"

    overlay.add_completed_step("Inputs validated")

    # --- Phase 2: Load coordinate data from GPX / synthetic source ---
    overlay.update(0.08, "Loading Data", "Reading GPX file…")
    coord_data = _rg_load_coordinates(flags, props)
    if coord_data is None:
        overlay.finish()
        return
    coordinates, separate_paths, coordinates2, separate_paths_by_file = coord_data

    # --- Phase 3: Calculate and store trail statistics ---
    overlay.update(0.12, "Trail Statistics", "Computing distances & elevation gain…")
    _rg_compute_trail_stats(flags, coordinates)

    # --- Phase 4: Interpolate path to at least 300 points for a smooth curve ---
    overlay.update(0.16, "Path Interpolation", "Smoothing trail curve…")
    while len(coordinates) < 300 and len(coordinates) > 1 and "trail" in flags:
        i = 0
        while i < len(coordinates) - 1:
            p1 = coordinates[i]
            p2 = coordinates[i + 1]
            midpoint = (
                (p1[0] + p2[0]) / 2,
                (p1[1] + p2[1]) / 2,
                (p1[2] + p2[2]) / 2,
                p1[3],
            )
            coordinates.insert(i + 1, midpoint)
            i += 2

    # --- Phase 5: Calculate horizontal scale factor ---
    overlay.update(0.20, "Scale Calculation", "Computing horizontal scale…")
    scalecoords = coordinates
    if props['scalemode'] == "COORDINATES" and "gpx_scale" in flags:
        scalecoords = ((props['scaleLon1'], props['scaleLat1']), (props['scaleLon2'], props['scaleLat2']))
    scaleHor = calculate_scale(props['size'], scalecoords, type)
    bpy.context.scene.tp3d["sScaleHor"] = scaleHor

    # --- Phase 6: Convert to Blender coordinates and find map center ---
    overlay.update(0.24, "Coordinate Conversion", "Converting to Blender space…")
    blender_coords = [
        convert_to_blender_coordinates(lat, lon, ele, timestamp)
        for lat, lon, ele, timestamp in coordinates
    ]
    blender_coords_separate = []
    if "separate_paths" in flags or len(separate_paths) > 1:
        blender_coords_separate = [
            [convert_to_blender_coordinates(lat, lon, ele, timestamp) for lat, lon, ele, timestamp in path]
            for path in separate_paths
        ]
    blender_coords_by_file = []
    if separate_paths_by_file:
        blender_coords_by_file = [
            [[convert_to_blender_coordinates(lat, lon, ele, timestamp) for lat, lon, ele, timestamp in seg]
             for seg in file_segs]
            for file_segs in separate_paths_by_file
        ]
    min_x = min(p[0] for p in blender_coords)
    max_x = max(p[0] for p in blender_coords)
    min_y = min(p[1] for p in blender_coords)
    max_y = max(p[1] for p in blender_coords)
    centerx = (max_x - min_x) / 2 + min_x
    centery = (max_y - min_y) / 2 + min_y
    bpy.context.scene.tp3d["o_centerx"] = centerx
    bpy.context.scene.tp3d["o_centery"] = centery

    # --- Phase 7: Remove previously generated objects at the same location ---
    overlay.update(0.28, "Scene Cleanup", "Removing previous objects…")
    xOff = props['xTerrainOffset']
    yOff = props['yTerrainOffset']
    target_2d        = Vector((centerx, centery))
    target_2d_offset = Vector((centerx + xOff, centery + yOff))
    for obs in bpy.data.objects:
        obj_2d        = Vector((obs.location.x, obs.location.y))
        obj_2d_offset = obj_2d
        if "xTerrainOffset" in obs.keys() or "yTerrainOffset" in obs.keys():
            obj_2d_offset = Vector((obs.location.x - obs["xTerrainOffset"], obs.location.y - obs["yTerrainOffset"]))
        if (obj_2d - target_2d).length <= 0.2 or (obj_2d - target_2d_offset).length <= 0.2:
            bpy.data.objects.remove(obs, do_unlink=True)
        elif (obj_2d_offset - target_2d).length <= 0.2 or (obj_2d_offset - target_2d_offset).length <= 0.2:
            bpy.data.objects.remove(obs, do_unlink=True)
    bpy.ops.object.select_all(action='DESELECT')

    overlay.add_completed_step("GPX data loaded")

    # --- Phase 8: Create base map shape ---
    overlay.update(0.33, "Building Map Shape", "Creating base mesh…")
    MapObject = _rg_create_map_object(flags, props, props['modelname'], centerx, centery)
    #MapObject = _rg_create_map_object(_GEN_FLAGS[10], props, props['modelname'], centerx, centery)

    props["currentMap"] = MapObject
    bpy.context.scene.tp3d.currentMap = MapObject

    zoom_camera_to_selected(MapObject)

    # Swap in trail_map GPX coordinates after the shape is positioned
    if "trail_map" in flags:
        coordinates = coordinates2

    overlay.add_completed_step("Map shape created")

    # --- Phase 9: Fetch terrain elevation data ---
    overlay.update(0.38, "Fetching Elevation Data", "Querying API — this may take a moment…")
    print("------------------------------------------------")
    print("FETCHING ELEVATION DATA FOR THE MAP")
    print("------------------------------------------------")
    bpy.ops.object.transform_apply(location=False, rotation=True, scale=True)

    def _elevation_progress(pct):
        t = pct / 100.0
        overlay.update(
            0.38 + t * (0.65 - 0.38),
            "Fetching Elevation Data",
            f"Querying elevation API…",
            sub_percent=t,
            sub_label="Tiles processed",
        )

    tileVerts, diff = get_tile_elevation(MapObject, progress_cb=_elevation_progress)
    print("Elevation Data fetched")
    overlay.sub_percent = None   # hide sub-bar now that elevation is done
    overlay.add_completed_step(f"Elevation fetched  ({len(tileVerts)} pts)")
    overlay.update(0.65, "Elevation Data Ready", f"{len(tileVerts)} points fetched")

    if len(tileVerts) < 1000:
        #show_message_box(
        #    f"Mesh has only {len(tileVerts)} Points. Increase Resolution for higher quality and more details(e.G Subdivision)",
        #    "INFO", "INFO"
        #)
        _progress.WarningsOverlay.add_warning(f"Mesh has only {len(tileVerts)} Points. Increase Resolution for higher Quality", "warn")
    if props['fixedElevationScale']:
        autoScale = 10 / (diff / 1000) if diff > 0 else 10
    else:
        autoScale = scaleHor
    bpy.context.scene.tp3d.sAutoScale = autoScale

    if not props['fixedElevationScale']:
        if diff == 0:
            _progress.WarningsOverlay.add_warning("Terrain seems to be really flat. If not intended, increase Elevation scale", icon="warn")
        elif (diff / 1000) * autoScale * props['scaleElevation'] < 2:
            _progress.WarningsOverlay.add_warning("Terrain seems to be really flat. If not intended, increase Elevation scale", icon="warn")

    # Recalculate blender coords with elevation applied, simplify, deduplicate
    blender_coords = [
        convert_to_blender_coordinates(lat, lon, ele, timestamp)
        for lat, lon, ele, timestamp in coordinates
    ]
    blender_coords = simplify_curve(blender_coords, .12)
    blender_coords = separate_duplicate_xy(blender_coords, 0.05)
    if ("separate_paths" in flags or len(separate_paths) > 1) and "trail_map" not in flags:
        blender_coords_separate = [
            [convert_to_blender_coordinates(lat, lon, ele, timestamp) for lat, lon, ele, timestamp in path]
            for path in separate_paths
        ]
    if separate_paths_by_file and "trail_map" not in flags:
        blender_coords_by_file = [
            [[convert_to_blender_coordinates(lat, lon, ele, timestamp) for lat, lon, ele, timestamp in seg]
             for seg in file_segs]
            for file_segs in separate_paths_by_file
        ]

    # Store real-world map scale
    lat1, lon1 = coordinates[0][0], coordinates[0][1]
    lat2, lon2 = coordinates[-1][0], coordinates[-1][1]
    tdist  = haversine(lat1, lon1, lat2, lon2)
    mscale = (tdist / props['size']) * 1000000
    bpy.context.scene.tp3d["o_mapScale"] = f"{mscale:.0f}"

    # --- Phase 10: Build trail curves ---
    overlay.update(0.70, "Building Trail", "Creating curve objects…")
    curveObj  = None
    curveObjs = None
    try:
        if ("gpx_file" in flags and "trail_map" not in flags and len(blender_coords_separate) <= 1) or "trail_map" in flags:
            # Single segment or trail_map: one curve directly
            create_curve_from_coordinates(blender_coords)
            curveObj = bpy.context.view_layer.objects.active
        elif "gpx_chain" in flags and blender_coords_by_file and "trail_map" not in flags and "trail" in flags:
            # Multi-file: create one object per file by joining its segments as separate splines
            curveObjs = []
            for file_segs in blender_coords_by_file:
                bpy.ops.object.select_all(action='DESELECT')
                for crds in file_segs:
                    create_curve_from_coordinates(crds)
                if len(file_segs) > 1:
                    bpy.ops.object.join()
                curveObjs.append(bpy.context.view_layer.objects.active)
        elif ("separate_paths" in flags or len(blender_coords_separate) > 1) and "trail_map" not in flags and "trail" in flags:
            # Single file with multiple segments: join all into one object
            bpy.ops.object.select_all(action='DESELECT')
            for crds in blender_coords_separate:
                create_curve_from_coordinates(crds)
            bpy.ops.object.join()
            curveObjs = [bpy.context.view_layer.objects.active]
    except Exception as e:
        show_message_box("Bad Response from API while creating the curve. If this happens everytime contact dev")
        overlay.finish()
        return

    if curveObjs is None:
        curveObjs = splitCurves(curveObj)
    curveObj  = None
    bpy.ops.object.select_all(action='DESELECT')

    if curveObjs:
        props["currentTrail"] = curveObjs[0]
        bpy.context.scene.tp3d.currentTrail = curveObjs[0]

    overlay.add_completed_step("Trail curve built")

    # --- Phase 11: Apply terrain elevation to mesh vertices ---
    overlay.update(0.75, "Applying Terrain", "Displacing mesh vertices…")
    mesh = MapObject.data
    lowestZ  = 1000
    highestZ = 0
    for i, vert in enumerate(mesh.vertices):
        vert.co.z = tileVerts[i] / 1000 * props['scaleElevation'] * autoScale
        lowestZ  = min(lowestZ,  vert.co.z)
        highestZ = max(highestZ, vert.co.z)
    additionalExtrusion = lowestZ
    bpy.context.scene.tp3d.sAdditionalExtrusion = additionalExtrusion
    bpy.context.scene.tp3d.lowestZ  = lowestZ
    bpy.context.scene.tp3d.highestZ = highestZ

    # Snap trail curves onto terrain surface
    if props['overwritePathElevation'] and curveObj is not None:
        RaycastCurveToMesh(curveObj, MapObject)
    if props['overwritePathElevation'] and curveObjs is not None:
        for tcrv in curveObjs:
            RaycastCurveToMesh(tcrv, MapObject)

    # Extrude map shape downward and set bottom face z
    bpy.context.view_layer.objects.active = MapObject
    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.mesh.extrude_region_move()
    bpy.ops.mesh.dissolve_faces()
    bpy.ops.transform.translate(value=(0, 0, -1))
    bpy.ops.object.mode_set(mode='OBJECT')

    obj = bpy.context.object
    mesh = obj.data
    selected_faces = [face for face in mesh.polygons if face.select]
    if selected_faces:
        for face in selected_faces:
            for vert_idx in face.vertices:
                mesh.vertices[vert_idx].co.z = additionalExtrusion - props['minThickness']
    else:
        print("No face selected.")

    # Shift all geometry so bottom face sits at the correct z
    bpy.context.view_layer.objects.active = MapObject
    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.transform.translate(value=(0, 0, -additionalExtrusion + props['minThickness']))
    bpy.ops.object.mode_set(mode='OBJECT')

    if curveObjs:
        for tcrv in curveObjs:
            bpy.context.view_layer.objects.active = tcrv
            bpy.ops.object.mode_set(mode='EDIT')
            bpy.ops.curve.select_all(action='SELECT')
            bpy.ops.transform.translate(value=(0, 0, -additionalExtrusion + props['minThickness']))
            bpy.ops.object.mode_set(mode='OBJECT')

    # Set object origins to tile location
    location = obj.location
    bpy.context.scene.cursor.location = location
    if curveObjs:
        for tcrv in curveObjs:
            tcrv.select_set(True)
            bpy.ops.object.origin_set(type="ORIGIN_CURSOR")
    recalculateNormals(obj)

    # --- Phase 12-13: Create text / plate overlays for text-based shapes ---
    overlay.update(0.82, "Shape Overlays", "Adding text and plate elements…")
    textobj   = None
    plateobj  = None
    shape     = props['shape']
    plateThickness = props['plateThickness']
    shapeRotation  = props['shapeRotation']
    bpy.ops.object.select_all(action='DESELECT')

    if shape == "HEXAGON INNER TEXT":
        textobj = HexagonInnerText(MapObject)
    if shape == "HEXAGON OUTER TEXT":
        textobj, plateobj = HexagonOuterText()
        obj.location.z += plateThickness
    if shape == "OCTAGON OUTER TEXT":
        textobj, plateobj = OctagonOuterText()
        obj.location.z += plateThickness
    if shape == "HEXAGON FRONT TEXT":
        textobj, plateobj = HexagonFrontText()
        obj.location.z += plateThickness
    if shape == "MEDAL":
        textobj, plateobj = MedalText()
        obj.location.z += plateThickness
    else:
        pass  # BottomText() — currently disabled

    if ("TEXT" in shape and curveObjs is not None and "INNER TEXT" not in shape) or \
       (shape == "MEDAL" and curveObjs is not None):
        for tcrv in curveObjs:
            tcrv.location.z += plateThickness

    # Plate insert
    bpy.ops.object.select_all(action='DESELECT')
    dist = bpy.context.scene.tp3d.plateInsertValue
    if shape in {"HEXAGON OUTER TEXT", "OCTAGON OUTER TEXT", "HEXAGON FRONT TEXT", "MEDAL"}:
        transform_MapObject(plateobj, props['xTerrainOffset'], props['yTerrainOffset'])
        transform_MapObject(textobj,  props['xTerrainOffset'], props['yTerrainOffset'])
        set_origin_to_3d_cursor(plateobj)
        set_origin_to_3d_cursor(textobj)
        if dist > 0:
            plateInsert(plateobj, obj)
            textobj.location.z += dist
        if shapeRotation != 0:
            textobj.rotation_euler[2] += shapeRotation * (3.14159265 / 180)

    # --- Material preview mode ---
    for area in bpy.context.screen.areas:
        if area.type == 'VIEW_3D':
            for space in area.spaces:
                if space.type == 'VIEW_3D':
                    space.shading.type = 'MATERIAL'

    # Apply BASE material to the map mesh
    mat = bpy.data.materials.get("BASE")
    obj.data.materials.clear()
    obj.data.materials.append(mat)

    # --- Phase 14: Create terrain overlay elements ---
    overlay.update(0.83, "Terrain Elements", "Adding elements…")
    terrain = _rg_build_terrain_elements(obj, scaleHor, curveObj=curveObjs[0] if curveObjs else None)

    # --- Phase 15: Single color mode processing ---
    overlay.update(0.95, "Coloring", "Applying single-color mode…")
    _rg_apply_single_color_mode(obj, curveObjs, terrain, props)

    return

    # Final road intersection and normal recalculation
    if terrain['roads']:
        boolean_operation(terrain['roads'], MapObject, "INTERSECT")
        terrain['roads'].location.z += 0.4
    recalculateNormals(obj)

    overlay.add_completed_step("Terrain applied")

    if type == 20:
        for i, crv in enumerate(curveObjs):
            tmp = merge_with_map(obj, crv, False, False)
            remove_objects(crv)
            curveObjs[i] = tmp
        


    # --- Phases 16-18: Assign materials, export, and finalize ---
    overlay.update(0.97, "Finalizing", "Assigning materials and exporting…")
    _rg_assign_materials_and_export(
        obj, curveObjs, textobj, plateobj, props, buggyDataset, start_time, exportformat, terrain
    )
    overlay.finish()
    _progress.WarningsOverlay.get().show()