Updated statcs/ splis/ and scrips/

scripts/cleanup_aux_xml.py

@@ -0,0 +1,30 @@
+import os
+from pathlib import Path
+
+def remove_aux_xml_files(dataset_path):
+    """Remove all QGIS-generated .aux.xml files from the dataset."""
+
+    dataset_path = Path(dataset_path)
+    removed_count = 0
+
+    print("=" * 70)
+    print("MatchGeo-DEM .aux.xml Cleanup")
+    print("=" * 70)
+
+    # Walk through all directories
+    for root, dirs, files in os.walk(dataset_path):
+        for file in files:
+            if file.endswith('.aux.xml'):
+                filepath = Path(root) / file
+                print(f"🗑️  Removing: {filepath}")
+                filepath.unlink()
+                removed_count += 1
+
+    print(f"\n✅ Removed {removed_count} .aux.xml files")
+    print("=" * 70)
+
+    return removed_count
+
+if __name__ == "__main__":
+    dataset_path = "/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/data"
+    remove_aux_xml_files(dataset_path)

scripts/convert_shp2anno.py

@@ -0,0 +1,74 @@
+'''
+Convert shapefile annotations to a format suitable for training a deep learning model. 
+
+'''
+
+#==============================================================================
+#%% IMPORTS
+#==============================================================================
+from pathlib import Path
+import geopandas as gpd
+from shapely.geometry import Point
+from shapely.geometry import box
+import rasterio
+import json
+import numpy as np
+import cv2
+from tqdm.auto import tqdm
+#==============================================================================
+#%% CONFIGURATION
+#==============================================================================
+
+KEY_ID = "BRA_SP"
+SHAPEFILE_PATH = Path('/home/sabrina/Documents/Tese/00_Dados/01_Keypoints_SHP/pontos_liberdadefinal.shp')
+IMG_DIR        = Path(f'/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/data/{KEY_ID}/tiles')
+ANNO_DIR       = Path(f'/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/data/{KEY_ID}/annotation')
+
+ANNO_DIR.mkdir(exist_ok=True)
+
+#==============================================================================
+#%% CONVERT SHAPEFILE TO JSON ANNOTATIONS
+#==============================================================================
+gdf = gpd.read_file(SHAPEFILE_PATH)
+
+img_files = sorted(IMG_DIR.glob('*.tif'))
+print(f"Found {len(img_files)} images to process.")
+
+for img_file in tqdm(img_files, desc="Processing images"):
+
+    with rasterio.open(img_file) as src:
+        profile = src.profile
+        transform = src.transform
+
+        # Check if there are point inf the gdf inside the image bounds
+        img_bounds = rasterio.transform.array_bounds(profile['height'], profile['width'], transform)
+        img_poly = box(*img_bounds)  
+        if not gdf.intersects(img_poly).any():
+            print(f"No keypoints found in {img_file.stem}, skipping.")
+            continue
+
+
+        # Intersect the GeoDataFrame with the image bounds to get only relevant keypoints
+        gdf_img = gdf[gdf.intersects(img_poly)]
+        # Convert to pixel coordinates
+        keypoints = []
+        for idx, row in gdf_img.iterrows():
+            geom = row.geometry
+            if isinstance(geom, Point):
+                x, y = geom.x, geom.y
+                # Convert to pixel coordinates
+                col, row = ~transform * (x, y)
+                keypoints.append((int(col)/profile['width'], int(row)/profile['height']))  # Normalize to [0, 1]
+            
+
+        # Create annotation dictionary
+        anno = {
+            "image": img_file.name,
+            "keypoints": keypoints
+        }
+        # Save annotation as JSON
+        anno_file = ANNO_DIR / f"{img_file.stem}.json"
+        with open(anno_file, 'w') as f:
+            json.dump(anno, f, indent=4)
+
+# %%

scripts/create_splits.py

@@ -0,0 +1,150 @@
+import os
+from pathlib import Path
+import json
+import random
+import csv
+from collections import defaultdict
+
+areas = {'ATA_MV', 'BRA_SP', 'CHN_WS', 'ESP_EH', 'FIN_LM', 'GER_BN', 'IDN_SV', 
+         'KAZ_AC', 'KSA_WA', 'NAM_HF', 'NZL_KP', 'PHL_TA', 'USA_GC'}
+
+data_path = Path("/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/data/")
+output_path = Path("/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/splits/")
+output_path.mkdir(parents=True, exist_ok=True)
+
+# Configuration
+SEED = 42
+TRAIN_RATIO = 0.8
+VAL_RATIO = 0.1
+TEST_RATIO = 0.1
+
+assert abs(TRAIN_RATIO + VAL_RATIO + TEST_RATIO - 1.0) < 1e-6, "Ratios must sum to 1.0"
+
+random.seed(SEED)
+
+print("=" * 80)
+print("MatchGeo-DEM Stratified Split Generator")
+print(f"Train: {TRAIN_RATIO:.0%} | Val: {VAL_RATIO:.0%} | Test: {TEST_RATIO:.0%}")
+print(f"Random seed: {SEED}")
+print("=" * 80)
+
+all_tiles = []
+
+# Collect all tiles per city
+for location in sorted(areas):
+    tiles_dir = data_path / location / "tiles"
+
+    if not tiles_dir.exists():
+        print(f"⚠️  {location}: No tiles directory found")
+        continue
+
+    city_tiles = []
+    for tile_file in sorted(tiles_dir.iterdir()):
+        if tile_file.suffix == '.tif':
+            tile_id = tile_file.stem
+            city_tiles.append({
+                "tile_id": tile_id,
+                "city": location,
+                "file": str(tile_file.relative_to(data_path.parent))
+            })
+
+    print(f"📁 {location}: {len(city_tiles)} tiles collected")
+    all_tiles.extend(city_tiles)
+
+print(f"\n📊 Total tiles: {len(all_tiles)}")
+
+# Group by city
+city_groups = defaultdict(list)
+for tile in all_tiles:
+    city_groups[tile["city"]].append(tile)
+
+# Stratified split: ensure each city is represented in each split
+train_tiles = []
+val_tiles = []
+test_tiles = []
+
+for city, tiles in sorted(city_groups.items()):
+    n = len(tiles)
+    random.shuffle(tiles)
+
+    n_train = max(1, int(n * TRAIN_RATIO))
+    n_val = max(1, int(n * VAL_RATIO))
+    # Test gets the remainder
+    n_test = n - n_train - n_val
+
+    # Adjust if test is too small
+    if n_test < 1 and n > 2:
+        n_train -= 1
+        n_test = 1
+
+    city_train = tiles[:n_train]
+    city_val = tiles[n_train:n_train + n_val]
+    city_test = tiles[n_train + n_val:]
+
+    train_tiles.extend(city_train)
+    val_tiles.extend(city_val)
+    test_tiles.extend(city_test)
+
+    print(f"\n📁 {city}:")
+    print(f"   Total: {n} | Train: {len(city_train)} | Val: {len(city_val)} | Test: {len(city_test)}")
+
+# Shuffle again within each split
+random.shuffle(train_tiles)
+random.shuffle(val_tiles)
+random.shuffle(test_tiles)
+
+print(f"\n{'='*80}")
+print(f"📊 FINAL SPLIT SIZES:")
+print(f"   Train: {len(train_tiles)} tiles ({len(train_tiles)/len(all_tiles):.1%})")
+print(f"   Val:   {len(val_tiles)} tiles ({len(val_tiles)/len(all_tiles):.1%})")
+print(f"   Test:  {len(test_tiles)} tiles ({len(test_tiles)/len(all_tiles):.1%})")
+print(f"{'='*80}")
+
+# City distribution per split
+print(f"\n📊 CITY DISTRIBUTION PER SPLIT:")
+for split_name, split_tiles in [("Train", train_tiles), ("Val", val_tiles), ("Test", test_tiles)]:
+    city_counts = defaultdict(int)
+    for tile in split_tiles:
+        city_counts[tile["city"]] += 1
+    print(f"\n{split_name}:")
+    for city in sorted(city_counts.keys()):
+        print(f"   {city}: {city_counts[city]} tiles")
+
+# Write CSV files
+def write_split_csv(tiles, filepath):
+    with open(filepath, 'w', newline='') as f:
+        writer = csv.DictWriter(f, fieldnames=["tile_id", "city", "file"])
+        writer.writeheader()
+        for tile in tiles:
+            writer.writerow(tile)
+
+write_split_csv(train_tiles, output_path / "train.csv")
+write_split_csv(val_tiles, output_path / "validation.csv")
+write_split_csv(test_tiles, output_path / "test.csv")
+
+print(f"\n✅ Splits saved to:")
+print(f"   {output_path / 'train.csv'}")
+print(f"   {output_path / 'validation.csv'}")
+print(f"   {output_path / 'test.csv'}")
+
+# Save JSON manifest
+split_manifest = {
+    "seed": SEED,
+    "ratios": {"train": TRAIN_RATIO, "validation": VAL_RATIO, "test": TEST_RATIO},
+    "total_tiles": len(all_tiles),
+    "splits": {
+        "train": len(train_tiles),
+        "validation": len(val_tiles),
+        "test": len(test_tiles)
+    },
+    "files": {
+        "train": str(output_path / "train.csv"),
+        "validation": str(output_path / "validation.csv"),
+        "test": str(output_path / "test.csv")
+    }
+}
+
+with open(output_path / "split_manifest.json", 'w') as f:
+    json.dump(split_manifest, f, indent=2)
+
+print(f"\n✅ Split manifest saved to: {output_path / 'split_manifest.json'}")

scripts/create_tiny_dataset.py

@@ -0,0 +1,282 @@
+import os
+from pathlib import Path
+import shutil
+import random
+from datetime import datetime
+
+try:
+    import rasterio
+    from rasterio.windows import from_bounds
+except ImportError:
+    raise ImportError("This script requires rasterio. Install it with: pip install rasterio")
+
+areas = {'ATA_MV', 'BRA_SP', 'CHN_WS', 'ESP_EH', 'FIN_LM', 'GER_BN', 'IDN_SV', 
+         'KAZ_AC', 'KSA_WA', 'NAM_HF', 'NZL_KP', 'PHL_TA', 'USA_GC'}
+
+data_path = Path("/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/data/")
+tiny_path = Path("/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1-tiny/data/")
+
+# Configuration
+SEED = 42
+N = 5              # <-- n x n tiles contiguous subset
+TILE_SIZE = 333    # Expected tile dimension in pixels
+INCLUDE_ANNOTATIONS = True
+
+random.seed(SEED)
+
+
+def build_tile_grid(tiles_src):
+    """
+    Reads all tiles and builds a 2D grid based on their top-left geographic corners.
+    Returns (grid, n_rows, n_cols) where grid[r][c] is a Path or None.
+    """
+    tile_info = []
+    for tile_path in tiles_src.iterdir():
+        if tile_path.suffix != '.tif':
+            continue
+        try:
+            with rasterio.open(tile_path) as src:
+                if src.width != TILE_SIZE or src.height != TILE_SIZE:
+                    print(f"   ⚠️ {tile_path.name} is {src.width}x{src.height}, "
+                          f"expected {TILE_SIZE}x{TILE_SIZE}")
+                # Top-left corner in geo coordinates
+                x, y = src.transform * (0, 0)
+                tile_info.append((y, x, tile_path))
+        except Exception as e:
+            print(f"   ⚠️ Error reading {tile_path.name}: {e}")
+            continue
+
+    if not tile_info:
+        return None, 0, 0
+
+    # Pixel size from first tile to set clustering tolerance
+    with rasterio.open(tile_info[0][2]) as src:
+        pixel_size = max(abs(src.transform.a), abs(src.transform.e))
+
+    # Tolerance: half the expected geo-distance between adjacent tile origins
+    tol = TILE_SIZE * pixel_size * 0.5
+
+    ys = [t[0] for t in tile_info]
+    xs = [t[1] for t in tile_info]
+
+    # Unique Y coordinates = rows (top to bottom, descending)
+    unique_ys = []
+    for y in sorted(ys, reverse=True):
+        if not unique_ys or abs(y - unique_ys[-1]) > tol:
+            unique_ys.append(y)
+
+    # Unique X coordinates = columns (left to right, ascending)
+    unique_xs = []
+    for x in sorted(xs):
+        if not unique_xs or abs(x - unique_xs[-1]) > tol:
+            unique_xs.append(x)
+
+    n_rows = len(unique_ys)
+    n_cols = len(unique_xs)
+
+    # Place each tile in the grid
+    grid = [[None for _ in range(n_cols)] for _ in range(n_rows)]
+    for y, x, path in tile_info:
+        row_idx = min(range(n_rows), key=lambda i: abs(y - unique_ys[i]))
+        col_idx = min(range(n_cols), key=lambda i: abs(x - unique_xs[i]))
+        grid[row_idx][col_idx] = path
+
+    return grid, n_rows, n_cols
+
+
+# ------------------------------------------------------------------
+print("=" * 80)
+print("MatchGeo-DEM Tiny Dataset Generator — n×n Tile Subset")
+print(f"Subset size: {N}x{N} tiles ({N*TILE_SIZE}x{N*TILE_SIZE} pixels)")
+print(f"Output: {tiny_path}")
+print("=" * 80)
+
+total_copied = 0
+total_size = 0
+
+for location in sorted(areas):
+    src_dir = data_path / location
+    dst_dir = tiny_path / location
+
+    if not src_dir.exists():
+        print(f"\n⚠️  {location}: Source not found, skipping")
+        continue
+
+    dst_dir.mkdir(parents=True, exist_ok=True)
+    print(f"\n📁 {location}:")
+
+    # ------------------------------------------------------------------
+    # 1. Build tile grid and select random n×n window
+    # ------------------------------------------------------------------
+    tiles_src = src_dir / "tiles"
+    if not tiles_src.exists():
+        print(f"   ⚠️ Tiles directory not found, skipping")
+        continue
+
+    grid, n_rows, n_cols = build_tile_grid(tiles_src)
+    if grid is None:
+        print(f"   ⚠️ No valid tiles found, skipping")
+        continue
+
+    print(f"   📐 Grid: {n_rows} rows × {n_cols} cols")
+
+    # Clamp window to actual grid size
+    win_h = min(N, n_rows)
+    win_w = min(N, n_cols)
+    max_row = n_rows - win_h
+    max_col = n_cols - win_w
+
+    start_row = random.randint(0, max_row) if max_row > 0 else 0
+    start_col = random.randint(0, max_col) if max_col > 0 else 0
+    end_row = start_row + win_h
+    end_col = start_col + win_w
+
+    if win_h < N or win_w < N:
+        print(f"   ℹ️ Grid smaller than {N}x{N}; using {win_h}x{win_w} window")
+    else:
+        print(f"   🎯 Window: rows {start_row}-{end_row-1}, cols {start_col}-{end_col-1}")
+
+    # Collect selected tiles
+    selected_tiles = []
+    for r in range(start_row, end_row):
+        for c in range(start_col, end_col):
+            if grid[r][c] is not None:
+                selected_tiles.append(grid[r][c])
+
+    if not selected_tiles:
+        print(f"   ⚠️ No tiles in selected window, skipping")
+        continue
+
+    # ------------------------------------------------------------------
+    # 2. Copy selected tiles
+    # ------------------------------------------------------------------
+    tiles_dst = dst_dir / "tiles"
+    tiles_dst.mkdir(parents=True, exist_ok=True)
+    selected_names = set()
+
+    for tile_path in selected_tiles:
+        dst = tiles_dst / tile_path.name
+        shutil.copy2(tile_path, dst)
+        total_size += tile_path.stat().st_size
+        selected_names.add(tile_path.stem)
+
+    total_copied += len(selected_tiles)
+    expected = win_h * win_w
+    if len(selected_tiles) < expected:
+        print(f"   ✅ Tiles: {len(selected_tiles)}/{expected} copied (incomplete grid)")
+    else:
+        print(f"   ✅ Tiles: {len(selected_tiles)}/{expected} copied")
+
+    # ------------------------------------------------------------------
+    # 3. Crop merged DEM to the exact bounds of selected tiles
+    # ------------------------------------------------------------------
+    merged_src = src_dir / f"{location}.tif"
+    merged_dst = dst_dir / f"{location}.tif"
+
+    if merged_src.exists():
+        # Union of selected tile bounds
+        left = float('inf')
+        bottom = float('inf')
+        right = float('-inf')
+        top = float('-inf')
+
+        for tile_path in selected_tiles:
+            with rasterio.open(tile_path) as src:
+                b = src.bounds
+                left = min(left, b.left)
+                bottom = min(bottom, b.bottom)
+                right = max(right, b.right)
+                top = max(top, b.top)
+
+        with rasterio.open(merged_src) as src:
+            window = from_bounds(left, bottom, right, top, src.transform)
+            window = window.round_lengths().round_offsets()
+
+            profile = src.profile.copy()
+            profile.update({
+                'height': int(window.height),
+                'width': int(window.width),
+                'transform': src.window_transform(window)
+            })
+
+            with rasterio.open(merged_dst, 'w', **profile) as dst:
+                dst.write(src.read(window=window))
+
+        size = merged_dst.stat().st_size
+        total_size += size
+        print(f"   ✅ Cropped DEM: {size/1024/1024:.1f} MB "
+              f"({int(window.width)}x{int(window.height)} px)")
+    else:
+        print(f"   ⚠️ Merged DEM not found")
+
+    # ------------------------------------------------------------------
+    # 4. Copy metadata (omit geojsons that no longer describe the subset)
+    # ------------------------------------------------------------------
+    for meta_file in [f"{location}_metadata.json", f"{location}.qmd"]:
+        src = src_dir / meta_file
+        dst = dst_dir / meta_file
+        if src.exists():
+            shutil.copy2(src, dst)
+    print(f"   ✅ Metadata copied (extent/tiles geojsons omitted)")
+
+    # ------------------------------------------------------------------
+    # 5. Copy annotations for selected tiles only
+    # ------------------------------------------------------------------
+    anno_src = src_dir / "annotations"
+    anno_dst = dst_dir / "annotations"
+
+    if INCLUDE_ANNOTATIONS and anno_src.exists():
+        anno_dst.mkdir(parents=True, exist_ok=True)
+        copied_anno = 0
+
+        for anno_file in anno_src.iterdir():
+            if anno_file.suffix == '.json' and anno_file.stem in selected_names:
+                dst = anno_dst / anno_file.name
+                shutil.copy2(anno_file, dst)
+                copied_anno += 1
+
+        print(f"   ✅ Annotations: {copied_anno} copied")
+
+# ------------------------------------------------------------------
+# Summary
+# ------------------------------------------------------------------
+total_mb = total_size / (1024 * 1024)
+total_gb = total_size / (1024 * 1024 * 1024)
+
+print(f"\n{'='*80}")
+print(f"📊 TINY DATASET SUMMARY:")
+print(f"   Subset size: up to {N}x{N} tiles ({N*TILE_SIZE}x{N*TILE_SIZE} pixels)")
+print(f"   Total tiles copied: {total_copied}")
+print(f"   Total size: {total_mb:.1f} MB ({total_gb:.2f} GB)")
+print(f"   Output path: {tiny_path}")
+print(f"{'='*80}")
+
+# Create README
+tiny_readme = tiny_path.parent / "README.txt"
+with open(tiny_readme, 'w') as f:
+    f.write(f"""MatchGeo-DEM Tiny Dataset
+=========================
+
+This is a SPATIAL SUBSET of the full MatchGeo-DEM dataset.
+Each city was cropped to a random contiguous {N}x{N} tile window.
+Each tile is {TILE_SIZE}x{TILE_SIZE} pixels.
+Total subset size per city: up to {N*TILE_SIZE}x{N*TILE_SIZE} pixels.
+
+Configuration:
+- Tiles per city: up to {N}x{N} = {N*N} tiles
+- Tile size: {TILE_SIZE}x{TILE_SIZE} pixels
+- Random seed: {SEED}
+- Total tiles: {total_copied}
+- Total size: {total_mb:.1f} MB
+
+NOTE: The original _extent.geojson and _tiles.geojson files were omitted
+because they no longer describe the cropped subset. Regenerate them from
+the cropped DEM if your pipeline requires them.
+
+For the full dataset, see:
+https://doi.org/10.5281/zenodo.19339008
+
+Last generated: {datetime.now().strftime('%Y-%m-%d')}
+""")
+
+print(f"\n✅ Tiny README saved to: {tiny_readme}")

scripts/crop_tiles.py

@@ -0,0 +1,118 @@
+'''
+Crop Dataset to 333x333 pixels for faster processing and testing.
+This script reads the original DEM images, crops them to the specified size, and saves the cropped versions in a new directory.
+
+The annotations are also updated accordingly to reflect the new image dimensions.
+'''
+#------------------------------------------------------------------------
+#%% IMPORTS
+from pathlib import Path
+import math
+import rasterio
+from rasterio.windows import Window
+from shapely.geometry import box
+import geopandas as gpd
+import numpy as np
+from tqdm.auto import tqdm
+#------------------------------------------------------------------------
+#%% CONFIGURATION
+
+AREAS = {'ATA_MV', 'BRA_SP', 'CHN_WS', 'ESP_EH', 'FIN_LM', 'GER_BN', 'IDN_SV', 'KAZ_AC', 'KSA_WA', 'NAM_HF', 'NZL_KP', 'PHL_TA', 'USA_GC'}
+
+#AREAS = {'ATA_MV'}
+
+WIDTH = 256
+HEIGHT = 256
+
+#------------------------------------------------------------------------
+for KEY_ID in tqdm(AREAS):
+
+    IMG_DIR = Path(f'/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/data/{KEY_ID}')
+    CROPPED_IMG_DIR = Path(IMG_DIR, 'tiles')
+    CROPPED_IMG_DIR.mkdir(exist_ok=True)
+    # CROP IMAGES
+    img_files = sorted(IMG_DIR.glob(f'{KEY_ID}.tif'), key=lambda x: x.stem)
+    dicto_records = {
+        'tile_id' : [],
+        'row_idx' : [],
+        'col_idx' : [],
+        'geometry': []
+    }
+
+    for img_file in tqdm(img_files, desc="Cropping images"):
+
+        # Create a folder for each City in the cropped directory
+        city = img_file.parent.name
+        with rasterio.open(img_file) as src:
+            crs = src.crs
+            img = src.read(1)
+
+            nodata = src.nodata if src.nodata is not None else -9999
+
+            n_rows = math.ceil(src.height / HEIGHT)
+            n_cols = math.ceil(src.width / WIDTH)
+
+            padded_w = n_cols * WIDTH
+            padded_h = n_rows * HEIGHT
+            pad_right = padded_w - src.width
+            pad_bottom = padded_h - src.height
+
+            if pad_right > 0 or pad_bottom > 0:
+                img = np.pad(
+                    img,
+                    ((0, pad_bottom), (0, pad_right)),
+                    mode='constant',
+                    constant_values=nodata
+                )
+
+            #----------------------------------------------
+            for row in range(n_rows):
+                for col in range(n_cols):
+                    row_off = row * HEIGHT
+                    col_off = col * WIDTH
+
+                    tile = img[row_off:row_off + HEIGHT, col_off:col_off + WIDTH]
+
+                    # Skip completely uniform (null) tiles
+                    if np.unique(tile).size == 1:
+                        print("Skipping null tile")
+                        continue
+
+                    window = Window(
+                        col_off=col_off,
+                        row_off=row_off,
+                        width=WIDTH,
+                        height=HEIGHT
+                    )
+
+                    transform = src.window_transform(window)
+                    cropped_image = src.read(1, window=window)
+                    left, bottom, right, top = src.window_bounds(window)
+                    
+                    profile = src.profile.copy()
+                    profile.update({
+                        "height": HEIGHT,
+                        "width": WIDTH,
+                        "transform": transform,
+                        "nodata": nodata  # ensure nodata is set correctly
+                    })
+
+                    out_file = Path(CROPPED_IMG_DIR, KEY_ID +  f'_{row+1:03d}_{col+1:03d}.tif')
+                    
+
+                    with rasterio.open(out_file, 'w', **profile) as dst:
+                        dst.write(cropped_image, 1)
+
+                    dicto_records['tile_id'].append(f"{img_file.stem}_{row+1:03d}_{col+1:03d}")
+                    dicto_records['row_idx'].append(row+1)
+                    dicto_records['col_idx'].append(col+1)
+                    dicto_records['geometry'].append(box(left, bottom, right, top))
+
+
+
+    print('Saving vector..')
+    TILES_FILE = Path(IMG_DIR, KEY_ID + '_tiles.geojson')
+    gdf = gpd.GeoDataFrame(dicto_records, crs = crs, geometry='geometry')
+
+    gdf.to_file(TILES_FILE, driver='GEOJSON', mode='a')
+    print(f"Saved files to {CROPPED_IMG_DIR}")

scripts/find_nodata.py

@@ -0,0 +1,66 @@
+import rasterio
+from pathlib import Path
+import numpy as np
+
+#areas = {'ATA_MV', 'BRA_SP', 'CHN_WS', 'ESP_EH', 'FIN_LM', 'GER_BN', 'IDN_SV', 
+#         'KAZ_AC', 'KSA_WA', 'NAM_HF', 'NZL_KP', 'PHL_TA', 'USA_GC'}
+
+areas = {'ATA_MV'}
+
+path = Path("/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/data")
+
+print("=" * 70)
+print("MatchGeo-DEM NoData Checker")
+print("=" * 70)
+
+for location in sorted(areas):
+    loc_path = Path(path, f"{location}/{location}.tif")
+
+    if not loc_path.exists():
+        print(f"\n⚠️  {location}: File not found at {loc_path}")
+        continue
+
+    with rasterio.open(loc_path) as src:
+        nodata = src.nodata
+        dtype = src.dtypes[0]
+        width = src.width
+        height = src.height
+        is_bigtiff = src.profile.get('bigtiff', 'NO')
+        is_tiled = src.profile.get('tiled', False)
+        compress = src.profile.get('compress', 'NONE')
+
+        print(f"\n📁 {location}")
+        print(f"   File: {loc_path}")
+        print(f"   Size: {width} x {height} pixels")
+        print(f"   Data type: {dtype}")
+        print(f"   Compression: {compress}")
+        print(f"   BigTIFF: {is_bigtiff}")
+        print(f"   Tiled: {is_tiled}")
+        print(f"   Current NoData: {nodata}")
+
+        if nodata == -9999.0:
+            print(f"   ✅ NoData already set to -9999.0 — no action needed")
+            continue
+
+        if nodata is None:
+            print(f"   ⚠️  NoData is NOT SET")
+        else:
+            print(f"   ⚠️  NoData is {nodata} — needs to be changed to -9999.0")
+
+        # Check actual data range
+        band = src.read(1)
+        actual_min = np.min(band)
+        actual_max = np.max(band)
+        print(f"   Data range: {actual_min:.2f} to {actual_max:.2f}")
+
+        # Check for existing -9999 values
+        has_neg9999 = np.any(band == -9999)
+        print(f"   Contains -9999 values: {has_neg9999}")
+
+        # Check for NaN values
+        has_nan = np.isnan(band).any()
+        print(f"   Contains NaN values: {has_nan}")
+
+print("\n" + "=" * 70)
+print("Run 'fix_nodata.py' to fix any issues found above.")
+print("=" * 70)

scripts/fix_nodata.py

@@ -0,0 +1,109 @@
+import rasterio
+from pathlib import Path
+import numpy as np
+
+#areas = {'ATA_MV', 'BRA_SP', 'CHN_WS', 'ESP_EH', 'FIN_LM', 'GER_BN', 'IDN_SV', 
+#         'KAZ_AC', 'KSA_WA', 'NAM_HF', 'NZL_KP', 'PHL_TA', 'USA_GC'}
+
+areas = {'ATA_MV'}
+
+path = Path("/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/data")
+
+
+
+print("=" * 70)
+print("MatchGeo-DEM NoData Fixer (Fixed)")
+print("=" * 70)
+
+for location in sorted(areas):
+    loc_path = Path(path, f"{location}/{location}.tif")
+
+    if not loc_path.exists():
+        print(f"\n⚠️  {location}: File not found — skipping")
+        continue
+
+    with rasterio.open(loc_path) as src:
+        nodata = src.nodata
+
+        # Check current state
+        profile = src.profile
+        is_bigtiff = profile.get('bigtiff', 'NO')
+        is_tiled = profile.get('tiled', False)
+        compress = profile.get('compress', 'NONE')
+        block_x = profile.get('blockxsize', 0)
+        block_y = profile.get('blockysize', 0)
+
+        needs_fix = (nodata != -9999.0 or is_bigtiff != 'YES' or 
+                     not is_tiled or compress != 'deflate')
+
+        if not needs_fix:
+            print(f"\n✅ {location}: Already perfect (NoData={nodata}, BigTIFF={is_bigtiff}, Tiled={is_tiled}, Deflate={compress})")
+            continue
+
+        print(f"\n🔧 {location}: Fixing...")
+        print(f"   Current: NoData={nodata}, BigTIFF={is_bigtiff}, Tiled={is_tiled}, Compress={compress}")
+
+        # Read the data
+        band = src.read(1)
+
+        # Handle existing NoData values
+        if nodata is not None and nodata != -9999.0:
+            band[band == nodata] = -9999
+            print(f"   Replaced old NoData ({nodata}) with -9999")
+
+        # Handle NaN values if present
+        if np.isnan(band).any():
+            nan_count = np.isnan(band).sum()
+            band = np.nan_to_num(band, nan=-9999)
+            print(f"   Replaced {nan_count} NaN values with -9999")
+
+        # Build profile from scratch to avoid conflicts
+        # Use GTiff driver with explicit options
+        kwargs = {
+            'driver': 'GTiff',
+            'height': band.shape[0],
+            'width': band.shape[1],
+            'count': 1,
+            'dtype': 'float32',
+            'crs': src.crs,
+            'transform': src.transform,
+            'nodata': -9999.0,
+            'tiled': True,
+            'blockxsize': 256,
+            'blockysize': 256,
+            'compress': 'deflate',
+            'predictor': 2,
+            'zlevel': 6,
+            'bigtiff': 'YES',
+            'interleave': 'band',
+        }
+
+        # Write the corrected file
+        output_path = loc_path.with_suffix('.fixed.tif')
+
+        try:
+            with rasterio.open(output_path, 'w', **kwargs) as dst:
+                dst.write(band, 1)
+
+            # Verify
+            with rasterio.open(output_path) as dst:
+                v_nodata = dst.nodata
+                v_bigtiff = dst.profile.get('bigtiff', 'NO')
+                v_tiled = dst.profile.get('tiled', False)
+                v_compress = dst.profile.get('compress', 'NONE')
+
+                print(f"   ✅ Fixed file: {output_path}")
+                print(f"   ✅ NoData: {v_nodata}")
+                print(f"   ✅ BigTIFF: {v_bigtiff}")
+                print(f"   ✅ Tiled: {v_tiled}")
+                print(f"   ✅ Compression: {v_compress}")
+
+        except Exception as e:
+            print(f"   ❌ ERROR writing {location}: {e}")
+            print(f"   💡 Try deleting {output_path} if it exists and re-run")
+            if output_path.exists():
+                output_path.unlink()
+
+print("\n" + "=" * 70)
+print("Done! Check .fixed.tif files.")
+print("=" * 70)

scripts/generate_checksums.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""
+generate_checksums.py
+=====================
+Generates SHA-256 checksums for all data files in the MatchGeo dataset.
+
+Usage:
+  python generate_checksums.py --data-root /path/to/MatchGeo-DEM-v1 --output checksums.sha256
+"""
+
+import hashlib
+import argparse
+from pathlib import Path
+
+
+def sha256_file(filepath):
+    """Return SHA-256 hex digest of a file."""
+    h = hashlib.sha256()
+    with open(filepath, "rb") as f:
+        for chunk in iter(lambda: f.read(8192 * 1024), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def main():
+
+    data_root = "/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1"
+    output = "checksums.sha256"
+    include = [".tif", ".json", ".geojson", ".csv", ".qmd", ".cff", ".md"]
+
+
+    data_root = Path(data_root)
+    output_path = Path(output)
+
+    print("=" * 60)
+    print("MatchGeo-DEM Checksum Generator")
+    print("=" * 60)
+
+    entries = []
+    for ext in include:
+        for filepath in sorted(data_root.rglob(f"*{ext}")):
+            if ".git" in str(filepath):
+                continue
+            rel = filepath.relative_to(data_root)
+            digest = sha256_file(filepath)
+            entries.append(f"{digest}  {rel}")
+            print(f"   {rel}")
+
+    output_path.write_text("\n".join(entries) + "\n", encoding="utf-8")
+    print(f"\n✅ {len(entries)} files hashed → {output_path}")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

scripts/generate_pdf_metadata.py

@@ -0,0 +1,338 @@
+#!/usr/bin/env python3
+"""
+generate_pdf_metadata.py
+========================
+Generates a human-readable PDF metadata report for MatchGeo-DEM.
+
+Requires: fpdf2
+Install:  pip install fpdf2
+
+Usage:
+  python generate_pdf_metadata.py --output MatchGeo-DEM_Metadata_Report.pdf
+"""
+
+import argparse
+from pathlib import Path
+from datetime import datetime
+
+try:
+    from fpdf import FPDF
+    HAS_FPDF = True
+except ImportError:
+    HAS_FPDF = False
+    raise ImportError("fpdf2 is required. Install: pip install fpdf2")
+
+
+CITIES = [
+    {"id": "ATA_MV", "name": "Mount Athos, Greece", "epsg": 3031, "resolution": 2.0, "method": "Satellite InSAR", "n_tiles": 5625, "labelled": False, "year": "2011–2015", "provider": "Copernicus DEM (ESA)"},
+    {"id": "BRA_SP", "name": "São Paulo, Brazil", "epsg": 31983, "resolution": 0.5, "method": "Airborne LiDAR", "n_tiles": 558, "labelled": True, "year": "2020", "provider": "GeoSampa (PMSP)"},
+    {"id": "CHN_WS", "name": "Wutai Shan, China", "epsg": 32649, "resolution": 1.0, "method": "UAV SfM", "n_tiles": 1076, "labelled": False, "year": "2021", "provider": "OpenTopography (Zhou, C.)"},
+    {"id": "ESP_EH", "name": "El Hierro, Spain", "epsg": 3040, "resolution": 1.0, "method": "Airborne LiDAR", "n_tiles": 2460, "labelled": False, "year": "2022–2025", "provider": "PNOA-LiDAR (CNIG)"},
+    {"id": "FIN_LM", "name": "Lahti, Finland", "epsg": 3067, "resolution": 2.0, "method": "LiDAR + Photogrammetry", "n_tiles": 248, "labelled": False, "year": "2020–2026", "provider": "National Land Survey of Finland"},
+    {"id": "GER_BN", "name": "Bonn, Germany", "epsg": 25832, "resolution": 1.0, "method": "Airborne LiDAR", "n_tiles": 1759, "labelled": True, "year": "2016–2018", "provider": "Geobasis NRW"},
+    {"id": "IDN_SV", "name": "Sinabung Volcano, Indonesia", "epsg": 32647, "resolution": 0.87, "method": "UAS SfM", "n_tiles": 181, "labelled": False, "year": "2018", "provider": "OpenTopography (Carr, B.)"},
+    {"id": "KAZ_AC", "name": "Almaty City, Kazakhstan", "epsg": 32643, "resolution": 1.0, "method": "Pleiades Tristereo", "n_tiles": 887, "labelled": False, "year": "2017", "provider": "OpenTopography (Amey et al.)"},
+    {"id": "KSA_WA", "name": "Wadi Al-Akhdar, Saudi Arabia", "epsg": 32637, "resolution": 1.6, "method": "SPOT 6 Stereo", "n_tiles": 3880, "labelled": False, "year": "2016", "provider": "OpenTopography (Matthieu et al.)"},
+    {"id": "NAM_HF", "name": "Hebron Fault, Namibia", "epsg": 32733, "resolution": 0.53, "method": "WorldView-3 Stereo", "n_tiles": 1457, "labelled": False, "year": "2017", "provider": "OpenTopography (Salomon et al.)"},
+    {"id": "NZL_KP", "name": "Kapiti Coast, New Zealand", "epsg": 2193, "resolution": 1.0, "method": "Airborne LiDAR", "n_tiles": 1776, "labelled": False, "year": "2010–2025", "provider": "LINZ"},
+    {"id": "PHL_TA", "name": "Tarlac, Philippines", "epsg": 32651, "resolution": 1.0, "method": "Airborne LiDAR", "n_tiles": 286, "labelled": False, "year": "2014–2017", "provider": "LiPAD (UP Diliman)"},
+    {"id": "USA_GC", "name": "Grand Canyon, United States", "epsg": 6341, "resolution": 10.0, "method": "LiDAR + IfSAR", "n_tiles": 600, "labelled": False, "year": "2020–2026", "provider": "USGS 3DEP"},
+]
+
+
+class PDF(FPDF):
+    def header(self):
+        if self.page_no() == 1:
+            return
+        self.set_font("Helvetica", "B", 10)
+        self.set_text_color(40, 40, 40)
+        self.cell(0, 8, "MatchGeo-DEM Dataset Metadata Report", border=0, align="L")
+        self.cell(0, 8, f"Page {self.page_no()}", border=0, align="R")
+        self.ln(10)
+        self.set_draw_color(180, 180, 180)
+        self.line(10, self.get_y(), 200, self.get_y())
+        self.ln(5)
+
+    def footer(self):
+        self.set_y(-15)
+        self.set_font("Helvetica", "I", 8)
+        self.set_text_color(128, 128, 128)
+        self.cell(0, 10, f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')} | DOI: 10.5281/zenodo.19339008", align="C")
+
+    def chapter_title(self, title, level=1):
+        if level == 1:
+            self.set_font("Helvetica", "B", 16)
+            self.set_text_color(0, 51, 102)
+            self.ln(8)
+            self.cell(0, 10, title, ln=True)
+            self.set_draw_color(0, 51, 102)
+            self.line(10, self.get_y(), 200, self.get_y())
+            self.ln(6)
+        else:
+            self.set_font("Helvetica", "B", 12)
+            self.set_text_color(0, 51, 102)
+            self.ln(6)
+            self.cell(0, 8, title, ln=True)
+            self.ln(2)
+
+    def body_text(self, text, bold=False):
+        self.set_font("Helvetica", "B" if bold else "", 10)
+        self.set_text_color(40, 40, 40)
+        self.multi_cell(0, 5, text)
+        self.ln(2)
+
+    def info_row(self, label, value):
+        self.set_font("Helvetica", "B", 10)
+        self.set_text_color(60, 60, 60)
+        self.cell(50, 6, label + ":", align="L")
+        self.set_font("Helvetica", "", 10)
+        self.set_text_color(40, 40, 40)
+        self.cell(0, 6, str(value), align="L")
+        self.ln()
+
+
+def generate_pdf(output_path):
+    pdf = PDF()
+    pdf.set_auto_page_break(auto=True, margin=15)
+    pdf.add_page()
+
+    # ===== COVER PAGE =====
+    pdf.set_font("Helvetica", "B", 24)
+    pdf.set_text_color(0, 51, 102)
+    pdf.ln(40)
+    pdf.cell(0, 15, "MatchGeo-DEM", ln=True, align="C")
+    pdf.set_font("Helvetica", "", 14)
+    pdf.cell(0, 10, "Multi-City Digital Elevation Model Dataset", ln=True, align="C")
+    pdf.cell(0, 10, "for Local Feature Matching", ln=True, align="C")
+    pdf.ln(20)
+
+    pdf.set_font("Helvetica", "", 11)
+    pdf.set_text_color(80, 80, 80)
+    pdf.multi_cell(0, 6, 
+        "This report provides a human-readable summary of the MatchGeo-DEM dataset "
+        "(Version 1.1), including its structure, provenance, licensing, and per-city coverage. "
+        "It is intended for data managers, reviewers, and users who need a quick reference "
+        "without opening machine-readable metadata files.",
+        align="C"
+    )
+    pdf.ln(30)
+
+    pdf.set_font("Helvetica", "B", 11)
+    pdf.set_text_color(40, 40, 40)
+    pdf.cell(0, 8, "Dataset DOI: 10.5281/zenodo.19339008", ln=True, align="C")
+    pdf.cell(0, 8, "License: CC BY 4.0", ln=True, align="C")
+    pdf.cell(0, 8, f"Report Date: {datetime.now().strftime('%Y-%m-%d')}", ln=True, align="C")
+    pdf.cell(0, 8, "Contact: sabrina.correa@ufv.br", ln=True, align="C")
+
+    # ===== OVERVIEW =====
+    pdf.add_page()
+    pdf.chapter_title("1. Dataset Overview")
+    pdf.body_text(
+        "MatchGeo is a curated, multi-city Digital Elevation Model (DEM) dataset designed for "
+        "training and benchmarking local feature matching algorithms in urban and natural terrain analysis. "
+        "It aggregates high-resolution elevation data from 13 distinct environments across 6 continents, "
+        "supporting cross-domain generalization studies under varying acquisition methods, climates, and terrain types."
+    )
+
+    pdf.info_row("Title", "MatchGeo: Multi-City DEM Dataset for Local Feature Matching")
+    pdf.info_row("Version", "1.1")
+    pdf.info_row("Release Date", "2026-05-11")
+    pdf.info_row("Total Cities", "13")
+    pdf.info_row("Total Tiles", "20,793")
+    pdf.info_row("Labelled Tiles", "213 (Bonn, Germany)")
+    pdf.info_row("Total Annotations", "27,000+ (handcrafted keypoints)")
+    pdf.info_row("Tile Size", "333 × 333 pixels")
+    pdf.info_row("Pixel Depth", "Float32")
+    pdf.info_row("NoData Value", "-9999")
+    pdf.info_row("Compression", "DEFLATE")
+    pdf.info_row("Format", "GeoTIFF (BigTIFF, tiled, OGC 23-008r3 compliant)")
+    pdf.ln(5)
+
+    pdf.chapter_title("2. Authors & Contact", level=2)
+    pdf.info_row("Authors", "Correa, S. P. L. P.; Santos, A. de Paula; Oliveira, H. N.; Beltons, D.")
+    pdf.info_row("Institution", "Universidade Federal de Viçosa (UFV)")
+    pdf.info_row("Contact", "sabrina.correa@ufv.br")
+    pdf.info_row("Repository", "https://doi.org/10.5281/zenodo.19339008")
+    pdf.ln(5)
+
+    # ===== LICENSE =====
+    pdf.chapter_title("3. License & Attribution", level=2)
+    pdf.body_text(
+        "This dataset is released under the Creative Commons Attribution 4.0 International License (CC BY 4.0). "
+        "You are free to share and adapt the material for any purpose, even commercially, provided you give "
+        "appropriate credit, provide a link to the license, and indicate if changes were made."
+    )
+    pdf.body_text(
+        "When using this dataset, you must cite the dataset DOI and acknowledge the original data providers "
+        "for each city used in your study. Full attribution statements are provided in the DATASET_DESCRIPTION.md file."
+    )
+    pdf.ln(5)
+
+    # ===== TECHNICAL SPECIFICATIONS =====
+    pdf.chapter_title("4. Technical Specifications", level=2)
+    pdf.info_row("Raster Format", "GeoTIFF (BigTIFF variant)")
+    pdf.info_row("Internal Tiling", "256 × 256 pixels")
+    pdf.info_row("Patch Dimensions", "333 × 333 pixels")
+    pdf.info_row("Data Type", "Float32")
+    pdf.info_row("Coordinate Systems", "City-specific UTM / local CRS (EPSG)")
+    pdf.info_row("Metadata Standard", "ISO 19115-2 + OGC 23-008r3")
+    pdf.info_row("Machine Catalog", "JSON-LD manifest.json + STAC 1.0.0 collection")
+    pdf.ln(5)
+
+    # ===== PROCESSING PIPELINE =====
+    pdf.chapter_title("5. Processing Pipeline", level=2)
+    pdf.body_text(
+        "All cities were processed through a standardized PDAL 2.6.0 pipeline with city-specific adaptations:"
+    )
+    steps = [
+        "1. Acquisition — Raw data retrieved from source portals in native CRS and resolution.",
+        "2. Preprocessing — City-specific filtering (ground classification, outlier removal, noise filtering).",
+        "3. Rasterization — PDAL writers.gdal with output_type=max (DSM), float32, nodata=-9999.",
+        "4. Standardization — BigTIFF, TILED=YES, COMPRESS=DEFLATE.",
+        "5. Patch Extraction — Non-overlapping 333×333 pixel grid (no resampling).",
+        "6. Annotation — Handcrafted keypoints in normalized coordinates (Bonn, São Paulo).",
+        "7. Metadata — Per-city ISO 19115-2 JSON; central JSON-LD manifest.",
+    ]
+    for step in steps:
+        pdf.body_text(step)
+    pdf.ln(5)
+
+    # ===== PER-CITY TABLE =====
+    pdf.add_page()
+    pdf.chapter_title("6. Per-City Coverage")
+    pdf.body_text(
+        "The following table summarizes each city's geographic coverage, acquisition method, resolution, "
+        "and annotation status. All tiles are 333×333 pixel GeoTIFF patches."
+    )
+    pdf.ln(3)
+
+    # Table header
+    pdf.set_fill_color(0, 51, 102)
+    pdf.set_text_color(255, 255, 255)
+    pdf.set_font("Helvetica", "B", 9)
+    pdf.cell(22, 7, "City", fill=True)
+    pdf.cell(45, 7, "Location", fill=True)
+    pdf.cell(30, 7, "Method", fill=True)
+    pdf.cell(18, 7, "Res (m)", fill=True)
+    pdf.cell(18, 7, "Tiles", fill=True)
+    pdf.cell(20, 7, "Labelled", fill=True)
+    pdf.cell(25, 7, "Year", fill=True)
+    pdf.ln()
+
+    # Table rows
+    pdf.set_text_color(40, 40, 40)
+    pdf.set_font("Helvetica", "", 8)
+    fill = False
+    for city in CITIES:
+        if pdf.get_y() > 260:
+            pdf.add_page()
+            pdf.set_fill_color(0, 51, 102)
+            pdf.set_text_color(255, 255, 255)
+            pdf.set_font("Helvetica", "B", 9)
+            pdf.cell(22, 7, "City", fill=True)
+            pdf.cell(45, 7, "Location", fill=True)
+            pdf.cell(30, 7, "Method", fill=True)
+            pdf.cell(18, 7, "Res (m)", fill=True)
+            pdf.cell(18, 7, "Tiles", fill=True)
+            pdf.cell(20, 7, "Labelled", fill=True)
+            pdf.cell(25, 7, "Year", fill=True)
+            pdf.ln()
+            pdf.set_text_color(40, 40, 40)
+            pdf.set_font("Helvetica", "", 8)
+            fill = False
+
+        pdf.set_fill_color(240, 240, 240) if fill else pdf.set_fill_color(255, 255, 255)
+        pdf.cell(22, 6, city["id"], fill=True)
+        pdf.cell(45, 6, city["name"], fill=True)
+        pdf.cell(30, 6, city["method"], fill=True)
+        pdf.cell(18, 6, str(city["resolution"]), fill=True)
+        pdf.cell(18, 6, str(city["n_tiles"]), fill=True)
+        pdf.cell(20, 6, "Yes" if city["labelled"] else "No", fill=True)
+        pdf.cell(25, 6, city["year"], fill=True)
+        pdf.ln()
+        fill = not fill
+
+    pdf.ln(5)
+    pdf.set_font("Helvetica", "I", 8)
+    pdf.set_text_color(100, 100, 100)
+    pdf.multi_cell(0, 4,
+        "Note: BRA_SP is marked as labelled in the dataset schema but currently has zero annotation files "
+        "(annotations pending). GER_BN contains 27,000+ handcrafted keypoint annotations.")
+
+    # ===== DATA SPLITS =====
+    pdf.add_page()
+    pdf.chapter_title("7. Data Splits")
+    pdf.body_text(
+        "The dataset is partitioned into train / validation / test splits stratified by city and difficulty. "
+        "Split manifests are provided as CSV files in the splits/ directory."
+    )
+    pdf.info_row("Train", "80%")
+    pdf.info_row("Validation", "10%")
+    pdf.info_row("Test", "10%")
+    pdf.info_row("Stratification", "By city and difficulty (flat, medium, steep, urban_density)")
+    pdf.ln(5)
+
+    # ===== KNOWN LIMITATIONS =====
+    pdf.chapter_title("8. Known Limitations", level=2)
+    limitations = [
+        "• Geographic bias: Dense annotations are currently available only for GER_BN. BRA_SP annotations are pending.",
+        "• Temporal mismatch: Data spans 2011–2026 across cities; users should account for temporal drift.",
+        "• Sensor heterogeneity: LiDAR, photogrammetry, SfM, and satellite stereo have different noise characteristics.",
+        "• Resolution heterogeneity: Native resolutions range from 0.5 m to 10 m; all tiles are 333×333 pixels.",
+        "• Missing data: Water bodies and ocean areas are excluded (NoData = -9999).",
+    ]
+    for lim in limitations:
+        pdf.body_text(lim)
+    pdf.ln(5)
+
+    # ===== CITATION =====
+    pdf.chapter_title("9. How to Cite", level=2)
+    pdf.body_text("Dataset citation (BibTeX):", bold=True)
+    pdf.set_font("Courier", "", 8)
+    pdf.set_text_color(40, 40, 40)
+    bibtex = """@dataset{correa_2026_matchgeo,
+  author = {Correa, S. P. L. P. and Santos, A. de Paula and Oliveira, H. N. and Beltons, D.},
+  title  = {MatchGeo: Multi-City Digital Elevation Model Dataset for Local Feature Matching},
+  year   = 2026,
+  publisher = {Zenodo},
+  version = {1.1},
+  doi    = {10.5281/zenodo.19339008},
+  url    = {https://doi.org/10.5281/zenodo.19339008}
+}"""
+    pdf.multi_cell(0, 4, bibtex)
+    pdf.ln(5)
+
+    pdf.set_font("Helvetica", "", 10)
+    pdf.body_text("Plain text citation:", bold=True)
+    pdf.body_text(
+        "Correa, S. P. L. P., Santos, A. de Paula, Oliveira, H. N., & Beltons, D. (2026). "
+        "MatchGeo: Multi-City Digital Elevation Model Dataset for Local Feature Matching (Version 1.1) [Data set]. "
+        "Zenodo. https://doi.org/10.5281/zenodo.19339008"
+    )
+
+    # ===== BACK PAGE =====
+    pdf.add_page()
+    pdf.set_font("Helvetica", "B", 14)
+    pdf.set_text_color(0, 51, 102)
+    pdf.ln(80)
+    pdf.cell(0, 10, "End of Report", ln=True, align="C")
+    pdf.set_font("Helvetica", "", 10)
+    pdf.set_text_color(100, 100, 100)
+    pdf.cell(0, 8, "For questions or bug reports, contact: sabrina.correa@ufv.br", ln=True, align="C")
+    pdf.cell(0, 8, "Zenodo: https://doi.org/10.5281/zenodo.19339008", ln=True, align="C")
+    pdf.cell(0, 8, "Hugging Face: https://huggingface.co/datasets/paeslemesa/matchgeo", ln=True, align="C")
+
+    # Save
+    pdf.output(output_path)
+    print(f"✅ PDF report saved: {output_path}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate MatchGeo-DEM PDF metadata report")
+    parser.add_argument("--output", default="MatchGeo-DEM_Metadata_Report.pdf", help="Output PDF path")
+    args = parser.parse_args()
+    generate_pdf(args.output)
+
+
+if __name__ == "__main__":
+    main()

scripts/generate_stac.py

@@ -0,0 +1,304 @@
+#!/usr/bin/env python3
+"""
+generate_stac.py
+================
+Creates STAC 1.0.0 metadata for the MatchGeo-DEM dataset.
+
+Outputs:
+  - stac/collection.json          — STAC Collection for the whole dataset
+  - stac/items/{city_id}.json     — STAC Item per city (merged DEM + tile assets)
+
+Requires: rasterio, shapely (optional but recommended)
+Install:  pip install rasterio shapely
+
+Usage:
+  python generate_stac.py --data-root /path/to/MatchGeo-DEM-v1/data
+"""
+
+import json
+import argparse
+from pathlib import Path
+from datetime import datetime
+from collections import OrderedDict
+
+try:
+    import rasterio
+    from rasterio.crs import CRS
+    HAS_RASTERIO = True
+except ImportError:
+    HAS_RASTERIO = False
+
+try:
+    from shapely.geometry import box, mapping
+    HAS_SHAPELY = True
+except ImportError:
+    HAS_SHAPELY = False
+
+
+# ------------------------------------------------------------------
+# Static dataset catalog (synchronized with manifest.json)
+# ------------------------------------------------------------------
+CITIES = [
+    {"id": "ATA_MV", "name": "Mount Athos, Greece", "epsg": 3031, "resolution": 2.0, "method": "satellite_insar", "n_tiles": 5625, "labelled": False, "year_start": 2011, "year_end": 2015, "provider": "Copernicus DEM"},
+    {"id": "BRA_SP", "name": "São Paulo, Brazil", "epsg": 31983, "resolution": 0.5, "method": "airborne_lidar", "n_tiles": 558, "labelled": True, "year_start": 2020, "year_end": 2020, "provider": "GeoSampa"},
+    {"id": "CHN_WS", "name": "Wutai Shan, China", "epsg": 32649, "resolution": 1.0, "method": "uav_sfm", "n_tiles": 1076, "labelled": False, "year_start": 2021, "year_end": 2021, "provider": "OpenTopography"},
+    {"id": "ESP_EH", "name": "El Hierro, Spain", "epsg": 3040, "resolution": 1.0, "method": "airborne_lidar", "n_tiles": 2460, "labelled": False, "year_start": 2022, "year_end": 2025, "provider": "PNOA-LiDAR"},
+    {"id": "FIN_LM", "name": "Lahti, Finland", "epsg": 3067, "resolution": 2.0, "method": "airborne_lidar_photogrammetry", "n_tiles": 248, "labelled": False, "year_start": 2020, "year_end": 2026, "provider": "National Land Survey of Finland"},
+    {"id": "GER_BN", "name": "Bonn, Germany", "epsg": 25832, "resolution": 1.0, "method": "airborne_lidar", "n_tiles": 1759, "labelled": True, "year_start": 2016, "year_end": 2018, "provider": "Geobasis NRW"},
+    {"id": "IDN_SV", "name": "Sinabung Volcano, Indonesia", "epsg": 32647, "resolution": 0.87, "method": "uas_sfm", "n_tiles": 181, "labelled": False, "year_start": 2018, "year_end": 2018, "provider": "OpenTopography"},
+    {"id": "KAZ_AC", "name": "Almaty City, Kazakhstan", "epsg": 32643, "resolution": 1.0, "method": "satellite_stereophotogrammetry", "n_tiles": 887, "labelled": False, "year_start": 2017, "year_end": 2017, "provider": "OpenTopography"},
+    {"id": "KSA_WA", "name": "Wadi Al-Akhdar, Saudi Arabia", "epsg": 32637, "resolution": 1.6, "method": "satellite_stereophotogrammetry", "n_tiles": 3880, "labelled": False, "year_start": 2016, "year_end": 2016, "provider": "OpenTopography"},
+    {"id": "NAM_HF", "name": "Hebron Fault, Namibia", "epsg": 32733, "resolution": 0.53, "method": "satellite_stereophotogrammetry", "n_tiles": 1457, "labelled": False, "year_start": 2017, "year_end": 2017, "provider": "OpenTopography"},
+    {"id": "NZL_KP", "name": "Kapiti Coast, New Zealand", "epsg": 2193, "resolution": 1.0, "method": "airborne_lidar", "n_tiles": 1776, "labelled": False, "year_start": 2010, "year_end": 2025, "provider": "LINZ"},
+    {"id": "PHL_TA", "name": "Tarlac, Philippines", "epsg": 32651, "resolution": 1.0, "method": "airborne_lidar", "n_tiles": 286, "labelled": False, "year_start": 2014, "year_end": 2017, "provider": "LiPAD"},
+    {"id": "USA_GC", "name": "Grand Canyon, United States", "epsg": 6341, "resolution": 10.0, "method": "lidar_ifsar", "n_tiles": 600, "labelled": False, "year_start": 2020, "year_end": 2026, "provider": "USGS 3DEP"},
+]
+
+
+# ------------------------------------------------------------------
+# Helpers
+# ------------------------------------------------------------------
+def read_raster_bounds(tif_path):
+    """Return (bbox, crs_wkt, width, height) from a GeoTIFF."""
+    if not HAS_RASTERIO:
+        return None, None, None, None
+    try:
+        with rasterio.open(tif_path) as src:
+            bounds = src.bounds
+            bbox = [bounds.left, bounds.bottom, bounds.right, bounds.top]
+            return bbox, src.crs.to_wkt(), src.width, src.height
+    except Exception as e:
+        print(f"    ⚠️ Could not read {tif_path}: {e}")
+        return None, None, None, None
+
+
+def bbox_to_geometry(bbox):
+    """Convert [minx, miny, maxx, maxy] to GeoJSON Polygon dict."""
+    if HAS_SHAPELY and bbox:
+        return mapping(box(*bbox))
+    # Fallback manual geometry
+    if bbox:
+        return {
+            "type": "Polygon",
+            "coordinates": [[
+                [bbox[0], bbox[1]], [bbox[2], bbox[1]],
+                [bbox[2], bbox[3]], [bbox[0], bbox[3]],
+                [bbox[0], bbox[1]]
+            ]]
+        }
+    return None
+
+
+def build_collection(data_root, output_dir):
+    """Build the STAC Collection JSON."""
+    collection = OrderedDict()
+    collection["type"] = "Collection"
+    collection["stac_version"] = "1.0.0"
+    collection["id"] = "matchgeo-dem-v1"
+    collection["title"] = "MatchGeo: Multi-City DEM Dataset for Local Feature Matching"
+    collection["description"] = (
+        "MatchGeo is a curated, multi-city Digital Elevation Model (DEM) dataset "
+        "designed for training and benchmarking local feature matching algorithms "
+        "in urban and natural terrain analysis. It aggregates high-resolution elevation "
+        "data from 13 distinct environments across 6 continents."
+    )
+    collection["license"] = "CC-BY-4.0"
+    collection["keywords"] = [
+        "DEM", "DSM", "elevation", "local feature matching",
+        "computer vision", "geospatial", "LiDAR", "photogrammetry"
+    ]
+    collection["providers"] = [
+        {
+            "name": "Correa, S. P. L. P.; Santos, A. de Paula; Oliveira, H. N.; Beltons, D.",
+            "roles": ["producer", "licensor"],
+            "url": "https://doi.org/10.5281/zenodo.19339008"
+        }
+    ]
+    collection["extent"] = {
+        "spatial": {"bbox": [[-180, -90, 180, 90]]},
+        "temporal": {
+            "interval": [["2011-01-01T00:00:00Z", "2026-12-31T23:59:59Z"]]
+        }
+    }
+    collection["links"] = [
+        {"rel": "self", "href": "./collection.json", "type": "application/json"},
+        {"rel": "root", "href": "./collection.json", "type": "application/json"},
+        {"rel": "license", "href": "../LICENSE", "type": "text/plain"},
+        {"rel": "cite-as", "href": "https://doi.org/10.5281/zenodo.19339008", "type": "text/html"}
+    ]
+    # Summaries
+    collection["summaries"] = {
+        "gsd": [0.5, 0.53, 0.87, 1.0, 1.6, 2.0, 10.0],
+        "eo:bands": [{"name": "elevation", "common_name": "elevation", "unit": "meter"}]
+    }
+    # Assets
+    collection["assets"] = {
+        "manifest": {
+            "href": "../manifest.json",
+            "type": "application/json",
+            "title": "Central dataset manifest (JSON-LD)"
+        },
+        "dataset_description": {
+            "href": "../DATASET_DESCRIPTION.md",
+            "type": "text/markdown",
+            "title": "FAIR-compliant dataset description"
+        }
+    }
+
+    out_path = output_dir / "collection.json"
+    out_path.write_text(json.dumps(collection, indent=2), encoding="utf-8")
+    print(f"✅ Collection written: {out_path}")
+    return collection
+
+
+def build_item(city, data_root, output_dir):
+    """Build a STAC Item for one city."""
+    city_id = city["id"]
+    city_dir = Path(data_root) / city_id
+    merged_tif = city_dir / f"{city_id}.tif"
+    tiles_dir = city_dir / "tiles"
+    anno_dir = city_dir / "annotations"
+    has_annotations = anno_dir.exists() and any(anno_dir.iterdir())
+
+    # Read merged DEM bounds
+    bbox, crs_wkt, width, height = read_raster_bounds(merged_tif)
+    geometry = bbox_to_geometry(bbox)
+
+    # Date handling
+    year_start = city.get("year_start", 2020)
+    year_end = city.get("year_end", 2020)
+    dt_start = f"{year_start}-01-01T00:00:00Z"
+    dt_end = f"{year_end}-12-31T23:59:59Z"
+
+    item = OrderedDict()
+    item["type"] = "Feature"
+    item["stac_version"] = "1.0.0"
+    item["id"] = city_id
+    item["collection"] = "matchgeo-dem-v1"
+    item["bbox"] = bbox if bbox else [-180, -90, 180, 90]
+    item["geometry"] = geometry if geometry else {"type": "Polygon", "coordinates": [[]]}
+    item["properties"] = {
+        "title": city["name"],
+        "description": f"{city['name']} — {city['method']} at {city['resolution']} m resolution",
+        "datetime": dt_start,
+        "start_datetime": dt_start,
+        "end_datetime": dt_end,
+        "providers": [{"name": city["provider"], "roles": ["producer"]}],
+        "gsd": city["resolution"],
+        "proj:epsg": city["epsg"],
+        "matchgeo:method": city["method"],
+        "matchgeo:n_tiles": city["n_tiles"],
+        "matchgeo:labelled": city["labelled"],
+        "matchgeo:has_annotations": has_annotations,
+    }
+    if crs_wkt:
+        item["properties"]["proj:wkt2"] = crs_wkt
+
+    # Assets
+    item["assets"] = {}
+    if merged_tif.exists():
+        item["assets"]["dem"] = {
+            "href": str(merged_tif.relative_to(Path(data_root).parent)),
+            "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+            "title": f"Merged DEM — {city_id}",
+            "roles": ["data"],
+            "eo:bands": [{"name": "elevation", "common_name": "elevation", "unit": "meter"}]
+        }
+    if tiles_dir.exists():
+        item["assets"]["tiles"] = {
+            "href": str(tiles_dir.relative_to(Path(data_root).parent)) + "/",
+            "type": "application/x-geotiff-tiles",
+            "title": f"333×333 pixel tiles — {city_id}",
+            "roles": ["data"],
+            "x-asset-count": city["n_tiles"]
+        }
+    extent_geojson = city_dir / f"{city_id}_extent.geojson"
+    if extent_geojson.exists():
+        item["assets"]["extent"] = {
+            "href": str(extent_geojson.relative_to(Path(data_root).parent)),
+            "type": "application/geo+json",
+            "title": "Coverage extent polygon",
+            "roles": ["metadata"]
+        }
+    tiles_geojson = city_dir / f"{city_id}_tiles.geojson"
+    if tiles_geojson.exists():
+        item["assets"]["tile_index"] = {
+            "href": str(tiles_geojson.relative_to(Path(data_root).parent)),
+            "type": "application/geo+json",
+            "title": "Tile index (grid)",
+            "roles": ["metadata"]
+        }
+    meta_json = city_dir / f"{city_id}_metadata.json"
+    if meta_json.exists():
+        item["assets"]["metadata"] = {
+            "href": str(meta_json.relative_to(Path(data_root).parent)),
+            "type": "application/json",
+            "title": "ISO 19115-2 + OGC 23-008r3 metadata",
+            "roles": ["metadata"]
+        }
+    if has_annotations:
+        item["assets"]["annotations"] = {
+            "href": str(anno_dir.relative_to(Path(data_root).parent)) + "/",
+            "type": "application/json",
+            "title": "Keypoint annotations",
+            "roles": ["metadata"]
+        }
+
+    item["links"] = [
+        {"rel": "self", "href": f"./{city_id}.json", "type": "application/json"},
+        {"rel": "collection", "href": "../collection.json", "type": "application/json"},
+        {"rel": "root", "href": "../collection.json", "type": "application/json"}
+    ]
+
+    out_path = output_dir / "items" / f"{city_id}.json"
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text(json.dumps(item, indent=2), encoding="utf-8")
+    print(f"   ✅ Item written: {out_path}")
+    return item
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate STAC metadata for MatchGeo-DEM")
+    parser.add_argument("--data-root", required=True, help="Path to MatchGeo-DEM-v1/data/")
+    parser.add_argument("--output", default="stac", help="Output directory for STAC files")
+    args = parser.parse_args()
+
+    data_root = Path(args.data_root)
+    output_dir = Path(args.output)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    print("=" * 60)
+    print("MatchGeo-DEM STAC Generator v1.0")
+    print("=" * 60)
+
+    # Build collection
+    print("\n📦 Building Collection...")
+    collection = build_collection(data_root, output_dir)
+
+    # Build items
+    print("\n🗺️  Building Items...")
+    for city in CITIES:
+        build_item(city, data_root, output_dir)
+
+    # Update collection links with item references
+    for city in CITIES:
+        collection["links"].append({
+            "rel": "item",
+            "href": f"./items/{city['id']}.json",
+            "type": "application/json"
+        })
+
+    # Rewrite collection with item links
+    (output_dir / "collection.json").write_text(
+        json.dumps(collection, indent=2), encoding="utf-8"
+    )
+
+    print("\n" + "=" * 60)
+    print("✅ STAC metadata complete!")
+    print(f"   Collection: {output_dir / 'collection.json'}")
+    print(f"   Items:      {output_dir / 'items/'}")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

scripts/get_data_metadata.py

@@ -0,0 +1,36 @@
+#%%
+from pathlib import Path
+import rasterio
+
+
+path = Path("/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1")
+cities = {'ATA_MV', 'BRA_SP', 'CHN_WS', 'ESP_EH' ,'FIN_LM', 'GER_BN' ,'IDN_SV', 'KAZ_AC', 'KSA_WA' ,'NAM_HF' ,'NZL_KP' ,'PHL_TA', 'USA_GC'}
+
+print("===============================================\nEPSG")
+# 1. Get EPSG and WKT for all cities
+for city in {'ATA_MV', 'BRA_SP', 'CHN_WS', 'ESP_EH' ,'FIN_LM', 'GER_BN' ,'IDN_SV', 'KAZ_AC', 'KSA_WA' ,'NAM_HF' ,'NZL_KP' ,'PHL_TA', 'USA_GC'}:
+    with rasterio.open(str(path) + f"/{city}/{city}.tif") as src:
+        print( f"{city}: {src.crs}")
+
+
+#%%
+print("===============================================\nNumber of Tiles")
+# 2. Count tiles per city
+for city in cities:
+    tile_path = Path(path, f"{city}/tiles")
+    ntiles = list(tile_path.glob("*.tif"))
+    print(f"{city} : {len(ntiles)}")
+
+#%%
+print("===============================================\nBounding Box")
+# 3. Get bounding box from GeoJSON
+for city in cities:
+    with rasterio.open(Path(path, f"{city}/{city}.tif")) as src:
+        profile = src.profile
+        bounds = src.bounds
+        print(f"{city} : {bounds}")
+
+
+
+
+# %%

scripts/get_dataset_sizes.py

@@ -0,0 +1,84 @@
+import os
+from pathlib import Path
+import json
+
+areas = {'ATA_MV', 'BRA_SP', 'CHN_WS', 'ESP_EH', 'FIN_LM', 'GER_BN', 'IDN_SV', 
+         'KAZ_AC', 'KSA_WA', 'NAM_HF', 'NZL_KP', 'PHL_TA', 'USA_GC'}
+
+data_path = Path("/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/data/")
+
+print("=" * 80)
+print("MatchGeo-DEM Directory Size Report")
+print("=" * 80)
+print(f"{'City':<12} {'Tiles':>8} {'Merged (MB)':>12} {'Tiles (MB)':>12} {'Total (MB)':>12} {'Total (GB)':>10}")
+print("-" * 80)
+
+total_size = 0
+total_tiles = 0
+results = {}
+
+for location in sorted(areas):
+    loc_path = data_path / location
+
+    if not loc_path.exists():
+        print(f"{location:<12} {'N/A':>8} {'N/A':>12} {'N/A':>12} {'N/A':>12} {'N/A':>10}")
+        continue
+
+    # Count tiles
+    tiles_dir = loc_path / "tiles"
+    n_tiles = 0
+    tiles_size = 0
+    if tiles_dir.exists():
+        for f in tiles_dir.iterdir():
+            if f.suffix == '.tif':
+                n_tiles += 1
+                tiles_size += f.stat().st_size
+
+    # Merged file size
+    merged_file = loc_path / f"{location}.tif"
+    merged_size = merged_file.stat().st_size if merged_file.exists() else 0
+
+    # Also check fixed file
+    fixed_file = loc_path / f"{location}.fixed.tif"
+    if fixed_file.exists():
+        merged_size = max(merged_size, fixed_file.stat().st_size)
+
+    # Total size
+    city_total = merged_size + tiles_size
+
+    # Convert to MB/GB
+    merged_mb = merged_size / (1024 * 1024)
+    tiles_mb = tiles_size / (1024 * 1024)
+    total_mb = city_total / (1024 * 1024)
+    total_gb = city_total / (1024 * 1024 * 1024)
+
+    print(f"{location:<12} {n_tiles:>8} {merged_mb:>12.1f} {tiles_mb:>12.1f} {total_mb:>12.1f} {total_gb:>10.2f}")
+
+    total_size += city_total
+    total_tiles += n_tiles
+
+    results[location] = {
+        "n_tiles": n_tiles,
+        "merged_mb": round(merged_mb, 2),
+        "tiles_mb": round(tiles_mb, 2),
+        "total_mb": round(total_mb, 2),
+        "total_gb": round(total_gb, 2)
+    }
+
+print("-" * 80)
+total_mb = total_size / (1024 * 1024)
+total_gb = total_size / (1024 * 1024 * 1024)
+print(f"{'TOTAL':<12} {total_tiles:>8} {'---':>12} {'---':>12} {total_mb:>12.1f} {total_gb:>10.2f}")
+print("=" * 80)
+
+# Save to JSON
+output_path = data_path.parent / "size_report.json"
+with open(output_path, 'w') as f:
+    json.dump({
+        "per_city": results,
+        "total_tiles": total_tiles,
+        "total_mb": round(total_mb, 2),
+        "total_gb": round(total_gb, 2)
+    }, f, indent=2)
+
+print(f"\n✅ Size report saved to: {output_path}")

scripts/metadata_update_createcsv.py

@@ -0,0 +1,90 @@
+#%%
+from pathlib import Path
+import pandas as pd
+import rasterio
+from rasterio.warp import transform_bounds
+
+#%%
+# IMPORTS
+DATA_FOLDER = Path("/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/data")
+
+REGIONS = {'ATA_MV', 'BRA_SP', 'CHN_WS', 'ESP_EH', 'FIN_LM', 'GER_BN', 'IDN_SV', 'KAZ_AC', 'KSA_WA', 'NAM_HF', 'NZL_KP', 'PHL_TA', 'USA_GC'}
+
+#%%
+
+dict_profile = {
+    "region": [],
+    "file_size_mb": [],
+    "nodata": [],
+    "crs": [],
+    "dtype": [],
+    "resolution":[],
+    "width": [],
+    "heigth": [],
+    "n_tiles": [],
+    "tile_size": [],
+    "x_min": [],
+    "x_max": [],
+    "y_min": [],
+    "y_max": [],
+    "long_min": [],
+    "long_max": [],
+    "lat_min": [],
+    "lat_max": [],
+}
+
+#%%
+for region in REGIONS:
+        
+    # Get merged file size
+    tif_path = Path(DATA_FOLDER, f"{region}/{region}.tif")
+    file_size = tif_path.stat().st_size / (10**6)
+
+    # Get raster profile and bounds
+    with rasterio.open(tif_path) as src:
+        profile = src.profile
+        bounds = src.bounds
+        try:
+            lonlat_bounds = transform_bounds(src.crs, "EPSG:4326", *bounds)
+        except:
+            lonlat_bounds = transform_bounds("EPSG:25832", "EPSG:4326", *bounds)
+          
+
+    # Get number of tiles
+    tile_path = Path(DATA_FOLDER, f"{region}/tiles")
+    n_tiles = len(list(tile_path.glob("*.tif")))
+
+    # Get tile size
+    tile0 = list(tile_path.glob("*.tif"))[0]
+    with rasterio.open(tile0) as src:
+        tile_size = src.width
+
+    # Update dictionary
+    dict_profile['region'].append(region)
+    dict_profile['file_size_mb'].append(file_size)
+    dict_profile['nodata'].append(profile.get('nodata'))
+    dict_profile['crs'].append(str(profile['crs']))
+    dict_profile['dtype'].append(profile['dtype'])
+    dict_profile['resolution'].append(profile['transform'][0])
+    dict_profile['width'].append(profile['width'])
+    dict_profile['heigth'].append(profile['height'])
+    dict_profile['n_tiles'].append(n_tiles)
+    dict_profile['tile_size'].append(tile_size)
+    dict_profile['x_min'].append(bounds.left)
+    dict_profile['x_max'].append(bounds.right)
+    dict_profile['y_min'].append(bounds.bottom)
+    dict_profile['y_max'].append(bounds.top)
+    dict_profile['long_min'].append(lonlat_bounds[0])
+    dict_profile['long_max'].append(lonlat_bounds[2])
+    dict_profile['lat_min'].append(lonlat_bounds[1])
+    dict_profile['lat_max'].append(lonlat_bounds[3])
+
+#%%
+# Create DataFrame
+df = pd.DataFrame(dict_profile)
+print(df)
+# %%
+
+df.to_csv(Path(DATA_FOLDER, "metadadata.csv"))
+
+# %%

scripts/metadata_update_info.py

@@ -0,0 +1,254 @@
+#!/usr/bin/env python3
+"""
+Update GeoMatch-DEM metadata JSON files from a CSV summary.
+
+Usage:
+    python update_metadata_from_csv.py <csv_file> <metadata_dir> [--fix-ata-mv]
+
+The script reads a CSV with raster-derived statistics and updates the
+corresponding *_metadata.json files in-place (with backup).
+"""
+
+import argparse
+import csv
+import json
+import shutil
+from pathlib import Path
+
+
+def fix_ata_mv_processing(json_data: dict) -> dict:
+    """
+    ATA_MV_metadata.json has a syntax error: the 'processing' section is
+    missing its opening key and 'pipeline' array. This reconstructs it
+    from the trailing fields that are present in the file.
+    """
+    if "processing" in json_data:
+        return json_data
+
+    # Reconstruct processing section based on file notes and sibling files
+    json_data["processing"] = {
+        "software": "PDAL",
+        "software_version": "2.6.0",
+        "python_version": "3.10.20",
+        "pipeline": [
+            {
+                "stage": "readers.las",
+                "description": "Read LAZ point cloud"
+            },
+            {
+                "stage": "writers.gdal",
+                "description": "Rasterize to DSM (max height per cell)",
+                "parameters": {
+                    "resolution": json_data["raster"]["resolution_meters"],
+                    "output_type": "max",
+                    "data_type": "float32",
+                    "nodata": -9999,
+                    "gdalopts": "COMPRESS=DEFLATE|TILED=YES|BIGTIFF=YES|BLOCKXSIZE=256|BLOCKYSIZE=256",
+                    "override_srs": json_data["spatial"]["crs"]["name"]
+                }
+            }
+        ],
+        "output_type": "max",
+        "gdal_options": "COMPRESS=DEFLATE|TILED=YES|BIGTIFF=YES|BLOCKXSIZE=256|BLOCKYSIZE=256",
+        "resampling": "none",
+        "patch_extraction": {
+            "method": "grid_split",
+            "patch_size": [256, 256],
+            "overlap": 0,
+            "resampling": "none"
+        }
+    }
+    return json_data
+
+
+def parse_csv(csv_path: Path) -> dict[str, dict]:
+    """Read CSV and return dict keyed by region code."""
+    rows = {}
+    with open(csv_path, "r", encoding="utf-8", newline="") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            region = row["region"]
+            rows[region] = row
+    return rows
+
+
+def update_json_from_csv(json_data: dict, csv_row: dict) -> dict:
+    """
+    Update JSON metadata with values derived from the actual raster file.
+    
+    Mapping:
+        CSV field          -> JSON path
+        ----------------    --------------------------------------------
+        file_size_mb       -> (new top-level field, not in schema)
+        nodata             -> raster.nodata_value
+        crs                -> spatial.crs (parsed for EPSG code)
+        dtype              -> raster.data_type
+        resolution         -> raster.resolution_meters
+        width              -> spatial.tile_index.tile_size_pixels[0]  (or new field)
+        heigth             -> spatial.tile_index.tile_size_pixels[1]  (or new field)
+        n_tiles            -> spatial.tile_index.n_tiles
+        tile_size          -> spatial.tile_index.tile_size_pixels
+        x_min, x_max       -> spatial.extent.bbox[0], bbox[2]
+        y_min, y_max       -> spatial.extent.bbox[1], bbox[3]
+        long_min, long_max -> spatial.extent.bbox_min_x/max_x (in degrees)
+        lat_min, lat_max   -> spatial.extent.bbox_min_y/max_y (in degrees)
+    """
+    
+    # --- spatial.extent ---
+    extent = json_data.setdefault("spatial", {}).setdefault("extent", {})
+    
+    # UTM bounds from CSV (projected coordinates)
+    x_min = float(csv_row["x_min"])
+    x_max = float(csv_row["x_max"])
+    y_min = float(csv_row["y_min"])
+    y_max = float(csv_row["y_max"])
+    
+    extent["bbox"] = [x_min, y_min, x_max, y_max]
+    #extent["bbox_min_x"] = x_min
+    #extent["bbox_min_y"] = y_min
+    #extent["bbox_max_x"] = x_max
+    #extent["bbox_max_y"] = y_max
+    
+    # Geographic bounds (lat/lon) - stored alongside projected bounds
+    # Note: The JSON schema doesn't have dedicated lat/lon bbox fields,
+    # so we add them as new fields in extent
+    extent["bbox_lonlat"] = [
+        float(csv_row["long_min"]),
+        float(csv_row["lat_min"]),
+        float(csv_row["long_max"]),
+        float(csv_row["lat_max"])
+    ]
+    #extent["lon_min"] = float(csv_row["long_min"])
+    #extent["lon_max"] = float(csv_row["long_max"])
+    #extent["lat_min"] = float(csv_row["lat_min"])
+    #extent["lat_max"] = float(csv_row["lat_max"])
+    
+    # --- spatial.tile_index ---
+    tile_index = json_data.setdefault("spatial", {}).setdefault("tile_index", {})
+    tile_index["n_tiles"] = int(csv_row["n_tiles"])
+    
+    # Tile size in pixels from CSV
+    tile_size_px = int(csv_row["tile_size"])
+    tile_index["tile_size_pixels"] = [tile_size_px, tile_size_px]
+    
+    # Tile size in meters: resolution * tile_size_pixels
+    resolution = float(csv_row["resolution"])
+    tile_size_m = resolution * tile_size_px
+    tile_index["tile_size_meters"] = [tile_size_m, tile_size_m]
+    
+    # --- raster ---
+    raster = json_data.setdefault("raster", {})
+    raster["data_type"] = csv_row["dtype"]
+    raster["nodata_value"] = float(csv_row["nodata"])
+    raster["resolution_meters"] = resolution
+    
+    # Internal tile dimensions (GeoTIFF block size)
+    raster["tile_dimensions"] = [tile_size_px, tile_size_px]
+    
+    # --- spatial.crs ---
+    # Parse EPSG from the CRS WKT string in CSV
+    crs_str = csv_row["crs"]
+    epsg_code = extract_epsg_from_crs(crs_str)
+    if epsg_code:
+        json_data["spatial"]["crs"]["epsg"] = epsg_code
+        json_data["spatial"]["crs"]["name"] = f"EPSG:{epsg_code}"
+    
+    # --- Add file_size_mb as a new top-level convenience field ---
+    json_data["file_size_mb"] = float(csv_row["file_size_mb"])
+    
+    return json_data
+
+
+def extract_epsg_from_crs(crs_str: str) -> int | None:
+    """Extract EPSG code from WKT or EPSG:xxxx string."""
+    if crs_str.startswith("EPSG:"):
+        try:
+            return int(crs_str.split(":")[1])
+        except (IndexError, ValueError):
+            pass
+    
+    # Try to find AUTHORITY["EPSG","xxxx"] pattern in WKT
+    import re
+    matches = re.findall(r'AUTHORITY\["EPSG","(\d+)"\]', crs_str)
+    if matches:
+        # Return the last match (usually the projection CRS, not datum/spheroid)
+        return int(matches[-1])
+    
+    # Try COMPD_CS or PROJCS with EPSG in name
+    match = re.search(r'EPSG[:\s]*(\d+)', crs_str)
+    if match:
+        return int(match.group(1))
+    
+    return None
+
+
+def load_json_robust(path: Path, fix_ata_mv: bool = False) -> dict:
+    """Load JSON, with optional repair for known-broken ATA_MV file."""
+    with open(path, "r", encoding="utf-8") as f:
+        content = f.read()
+    
+    try:
+        data = json.loads(content)
+    except json.JSONDecodeError as e:
+        raise
+    
+    if fix_ata_mv and "ATA_MV" in path.name:
+        data = fix_ata_mv_processing(data)
+    
+    return data
+
+
+
+def main():
+    REGIONS = {'ATA_MV', 'BRA_SP', 'CHN_WS', 'ESP_EH', 'FIN_LM', 'GER_BN', 'IDN_SV', 'KAZ_AC', 'KSA_WA', 'NAM_HF', 'NZL_KP', 'PHL_TA', 'USA_GC'}
+
+    csv_file = '/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/data/metadadata.csv'
+    dry_run = False
+    fix_ata_mv = False
+    for region in REGIONS:
+        metadata_dir = Path(f"/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/data/{region}/metadata")
+
+        csv_rows = parse_csv(csv_file)
+        print(f"Loaded {len(csv_rows)} rows from CSV")
+        
+        json_files = sorted(metadata_dir.glob("*_metadata.json"))
+        print(f"Found {len(json_files)} metadata JSON files")
+        
+        for json_path in json_files:
+            region = json_path.stem.replace("_metadata", "")
+            if region not in csv_rows:
+                print(f"  ⚠ No CSV row for {region}, skipping")
+                
+                continue
+            
+            print(f"  Processing {region}...")
+            
+            # Load JSON (with repair if needed)
+            json_data = load_json_robust(json_path, fix_ata_mv=fix_ata_mv)
+            
+            # Apply CSV updates
+            updated = update_json_from_csv(json_data, csv_rows[region])
+            
+            # Write back
+            if not dry_run:
+                backup_path = json_path.with_suffix(".json.bak")
+                shutil.copy2(json_path, backup_path)
+                
+                with open(json_path, "w", encoding="utf-8") as f:
+                    json.dump(updated, f, indent=2, ensure_ascii=False)
+                    f.write("\n")
+                
+                print(f"    ✓ Updated {json_path.name}")
+            else:
+                print(f"    [dry-run] Would update {json_path.name}")
+                # Print key changes for verification
+                print(f"      file_size_mb: {updated.get('file_size_mb')}")
+                print(f"      n_tiles: {updated['spatial']['tile_index']['n_tiles']}")
+                print(f"      resolution: {updated['raster']['resolution_meters']}")
+                print(f"      extent bbox: {updated['spatial']['extent']['bbox']}")
+        
+        print("Done!")
+
+
+if __name__ == "__main__":
+    main()

scripts/process_las.py

@@ -0,0 +1,165 @@
+from pathlib import Path
+import zipfile
+from tqdm import tqdm
+import json
+import pdal
+import time
+
+#======================================================
+#%%
+
+KEY_ID = "IRN_JJ"
+dirlaz = Path("/home/sabrina/Documents/Datasets/IRN_JJ")
+OUT_RESOLUTION = 1.5
+
+#======================================================
+#%%
+dirdem = Path(dirlaz, "dem")
+dirdem.mkdir(exist_ok=True, parents=True)
+
+filelaz = list(dirlaz.glob("*.laz"))
+print(f"Found {len(filelaz)} LAZ files.")
+
+
+#======================================================
+def laz_to_dem(key_id, input_laz: Path, output_tif: Path, resolution=1.0):
+    """
+    Convert a single LAZ file to DEM using PDAL.
+    """
+
+    if key_id == "KAZ-AC" :
+        pipeline = [ # PLEIADES DATA DO NOT USE SIMPLE MORPHOLOGICAL FILTER (SMRF)
+            {
+                "type": "readers.las",
+                "filename": str(input_laz),
+                "spatialreference": "EPSG:32643"
+            },
+            {
+                "type": "writers.gdal",
+                "filename": str(output_tif),
+                "resolution": resolution,
+                "output_type": "max",      
+                "data_type": "float32",
+                "nodata": -9999,
+                "gdalopts": "COMPRESS=DEFLATE|TILED=YES"
+            }
+        ]
+    elif key_id == 'BRA-SP':
+        pipeline = [ # AIRBORNE DATA USE SMRF
+            {
+                "type": "readers.las",
+                "filename": str(input_laz)
+            },
+            {
+                "type": "filters.smrf",
+                "scalar": 1.25,
+                "slope": 0.15,
+                "threshold": 0.5,
+                "window": 16.0
+            },
+            {
+                "type": "writers.gdal",
+                "filename": str(output_tif),
+                "resolution": resolution,
+                "output_type": "max",       # highest surface elevation per pixel
+                "data_type": "float32",
+                "nodata": -9999
+            }
+        ]
+
+    elif key_id == 'CHN-YG':
+           pipeline = [
+        {
+            "type": "readers.las",
+            "filename": str(input_laz),
+        },
+        {
+            "type": "filters.range",
+            "limits": "Classification![7:7]"
+        },
+        {
+            "type": "filters.outlier",
+            # Optional: SfM point clouds often contain isolated spurious points
+            # above/below the surface that are not flagged as Class 7.
+            # This applies a statistical filter (radius 1.0 m, 6 neighbours).
+            "method": "statistical",
+            "mean_k": 6,
+            "multiplier": 2.0
+        },
+        {
+            "type": "writers.gdal",
+            "filename": str(output_tif),
+            "resolution": resolution,
+            "output_type": "max",          # DSM: highest point per cell
+            "data_type": "float32",
+            "nodata": -9999,
+            "gdalopts": "COMPRESS=DEFLATE|TILED=YES|BIGTIFF=YES",
+            "override_srs": "EPSG:32648"
+        }
+        ]
+    elif key_id == 'IRN_JJ':
+            pipeline = [
+        {
+            "type": "readers.las",
+            "filename": str(input_laz),
+        },
+        {
+            "type": "filters.assign",
+            # The metadata shows Class 0 only (Created, never classified).
+            # No noise class exists, so we skip filters.range.
+            # This filter is a no-op placeholder for clarity.
+            "assignment": "Classification[:]=0"
+        },
+        {
+            "type": "filters.outlier",
+            "method": "statistical",
+            "mean_k": 6,
+            "multiplier": 2.0
+        },
+        {
+            "type": "writers.gdal",
+            "filename": str(output_tif),
+            "resolution": resolution,
+            "output_type": "max",          # DSM: highest point per cell
+            "data_type": "float32",
+            "nodata": -9999,
+            "gdalopts": "COMPRESS=DEFLATE|TILED=YES|BIGTIFF=YES",
+        }
+        ]
+    else:
+         print("Worng key id")
+         quit
+
+    p = pdal.Pipeline(json.dumps(pipeline))
+    p.execute()
+
+#======================================================
+def batch_laz_to_dem(input_dir, output_dir, key_id, resolution=1.0):
+    input_dir = Path(input_dir)
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    laz_files = list(input_dir.glob("*.laz")) + list(input_dir.glob("*.las"))
+
+    
+
+    for laz in tqdm(laz_files):
+        out_tif = output_dir / f"{laz.stem}.tif"
+
+        if Path(out_tif).exists == True:
+            print("File exists")
+            continue
+
+        else:
+            print(f"Processing: {laz.name}")
+            try:
+                laz_to_dem(input_laz=laz, output_tif= out_tif, resolution=resolution, key_id= key_id)
+            except Exception as e:
+                print(f"Error processing {laz.name}: {e}")
+
+
+#======================================================
+batch_laz_to_dem(input_dir = dirlaz,
+                output_dir =  dirdem,
+                key_id = KEY_ID,
+                resolution = OUT_RESOLUTION)

scripts/write_qgis_metadata.py

@@ -0,0 +1,325 @@
+import xml.etree.ElementTree as ET
+from pathlib import Path
+import json
+
+areas = {'ATA_MV', 'BRA_SP', 'CHN_WS', 'ESP_EH', 'FIN_LM', 'GER_BN', 'IDN_SV', 
+         'KAZ_AC', 'KSA_WA', 'NAM_HF', 'NZL_KP', 'PHL_TA', 'USA_GC'}
+
+data_path = Path("/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/")
+metadata_path = Path("/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/city_metadata/")
+
+# Load all metadata
+all_metadata = {}
+for location in areas:
+    meta_file = metadata_path / f"{location}_metadata.json"
+    if meta_file.exists():
+        with open(meta_file, 'r') as f:
+            all_metadata[location] = json.load(f)
+
+print("=" * 70)
+print("MatchGeo-DEM Complete QGIS .qmd Metadata Writer")
+print("=" * 70)
+
+for location in sorted(areas):
+    if location not in all_metadata:
+        print(f"\n⚠️  {location}: Metadata JSON not found — skipping")
+        continue
+
+    meta = all_metadata[location]
+
+    # Create QGIS metadata XML
+    root = ET.Element("qgis")
+    root.set("version", "3.40")
+
+    # IDENTIFICATION
+    ident = ET.SubElement(root, "identifier")
+    ident.text = meta["identification"]["tile_id"]
+
+    parent_ident = ET.SubElement(root, "parentidentifier")
+    parent_ident.text = "10.5281/zenodo.21229785"
+
+    lang = ET.SubElement(root, "language")
+    lang.text = "en-US"
+
+    type_el = ET.SubElement(root, "type")
+    type_el.text = "dataset"
+
+    title = ET.SubElement(root, "title")
+    title.text = f"MatchGeo-DEM: {meta['identification']['full_name']}"
+
+    abstract = ET.SubElement(root, "abstract")
+    abstract_text = (
+        f"Digital Surface Model (DSM) from {meta['acquisition']['source']}. "
+        f"Resolution: {meta['raster']['resolution_meters']}m. "
+        f"Method: {meta['acquisition']['method']}. "
+        f"Year: {meta['acquisition']['date_start'][:4]}-{meta['acquisition']['date_end'][:4]}. "
+        f"CRS: {meta['spatial']['crs']['name']}. "
+        f"NoData: {meta['raster']['nodata_value']}. "
+        f"Format: {meta['raster']['tiff_variant']}, {meta['raster']['compression']} compressed. "
+        f"Tiles: {meta['spatial']['tile_index']['n_tiles']} patches of 333x333 pixels. "
+        f"{meta.get('notes', '')}"
+    )
+    abstract.text = abstract_text
+
+    # CONTACTS
+    contacts = ET.SubElement(root, "contacts")
+    contact = ET.SubElement(contacts, "contact")
+
+    c_name = ET.SubElement(contact, "name")
+    c_name.text = "Sabrina Correa"
+
+    c_org = ET.SubElement(contact, "organization")
+    c_org.text = "Universidade Federal de Vicosa"
+
+    c_pos = ET.SubElement(contact, "position")
+    c_pos.text = "Dataset Maintainer"
+
+    c_voice = ET.SubElement(contact, "voice")
+    c_voice.text = ""
+
+    c_fax = ET.SubElement(contact, "fax")
+    c_fax.text = ""
+
+    c_email = ET.SubElement(contact, "email")
+    c_email.text = "sabrina.correa@ufv.br"
+
+    c_role = ET.SubElement(contact, "role")
+    c_role.text = "distributor"
+
+    # Also add original data provider as second contact
+    contact2 = ET.SubElement(contacts, "contact")
+    c2_name = ET.SubElement(contact2, "name")
+    c2_name.text = meta["acquisition"]["provider"]
+    c2_org = ET.SubElement(contact2, "organization")
+    c2_org.text = meta["acquisition"]["source"]
+    c2_pos = ET.SubElement(contact2, "position")
+    c2_pos.text = "Original Data Provider"
+    c2_voice = ET.SubElement(contact2, "voice")
+    c2_voice.text = ""
+    c2_fax = ET.SubElement(contact2, "fax")
+    c2_fax.text = ""
+    c2_email = ET.SubElement(contact2, "email")
+    c2_email.text = ""
+    c2_role = ET.SubElement(contact2, "role")
+    c2_role.text = "owner"
+
+    # LINKS
+    links = ET.SubElement(root, "links")
+
+    # Source link
+    link1 = ET.SubElement(links, "link")
+    l1_name = ET.SubElement(link1, "name")
+    l1_name.text = "Original Data Source"
+    l1_type = ET.SubElement(link1, "type")
+    l1_type.text = "WWW:LINK-1.0-http--link"
+    l1_url = ET.SubElement(link1, "url")
+    l1_url.text = meta["acquisition"]["url"]
+    l1_desc = ET.SubElement(link1, "description")
+    l1_desc.text = f"Official portal for {meta['acquisition']['source']}"
+    l1_format = ET.SubElement(link1, "format")
+    l1_format.text = "HTML"
+    l1_mime = ET.SubElement(link1, "mimeType")
+    l1_mime.text = "text/html"
+    l1_size = ET.SubElement(link1, "size")
+    l1_size.text = ""
+
+    # DOI link
+    doi = meta["acquisition"].get("doi", "10.5281/zenodo.19339008")
+    link2 = ET.SubElement(links, "link")
+    l2_name = ET.SubElement(link2, "name")
+    l2_name.text = "Dataset DOI"
+    l2_type = ET.SubElement(link2, "type")
+    l2_type.text = "DOI"
+    l2_url = ET.SubElement(link2, "url")
+    l2_url.text = f"https://doi.org/{doi}"
+    l2_desc = ET.SubElement(link2, "description")
+    l2_desc.text = "MatchGeo-DEM dataset DOI"
+    l2_format = ET.SubElement(link2, "format")
+    l2_format.text = "HTML"
+    l2_mime = ET.SubElement(link2, "mimeType")
+    l2_mime.text = "text/html"
+    l2_size = ET.SubElement(link2, "size")
+    l2_size.text = ""
+
+    # License link
+    link3 = ET.SubElement(links, "link")
+    l3_name = ET.SubElement(link3, "name")
+    l3_name.text = "License (CC BY 4.0)"
+    l3_type = ET.SubElement(link3, "type")
+    l3_type.text = "WWW:LINK-1.0-http--link"
+    l3_url = ET.SubElement(link3, "url")
+    l3_url.text = "https://creativecommons.org/licenses/by/4.0/"
+    l3_desc = ET.SubElement(link3, "description")
+    l3_desc.text = "Creative Commons Attribution 4.0 International"
+    l3_format = ET.SubElement(link3, "format")
+    l3_format.text = "HTML"
+    l3_mime = ET.SubElement(link3, "mimeType")
+    l3_mime.text = "text/html"
+    l3_size = ET.SubElement(link3, "size")
+    l3_size.text = ""
+
+    # REMA documentation link (for ATA_MV)
+    if location == "ATA_MV":
+        link4 = ET.SubElement(links, "link")
+        l4_name = ET.SubElement(link4, "name")
+        l4_name.text = "REMA Documentation"
+        l4_type = ET.SubElement(link4, "type")
+        l4_type.text = "WWW:LINK-1.0-http--link"
+        l4_url = ET.SubElement(link4, "url")
+        l4_url.text = "https://www.pgc.umn.edu/data/rema/"
+        l4_desc = ET.SubElement(link4, "description")
+        l4_desc.text = "Reference Elevation Model of Antarctica documentation"
+        l4_format = ET.SubElement(link4, "format")
+        l4_format.text = "HTML"
+        l4_mime = ET.SubElement(link4, "mimeType")
+        l4_mime.text = "text/html"
+        l4_size = ET.SubElement(link4, "size")
+        l4_size.text = ""
+
+    # DATES
+    dates = ET.SubElement(root, "dates")
+
+    date_created = ET.SubElement(dates, "date")
+    date_created.set("type", "Created")
+    date_created.text = meta["acquisition"]["date_start"]
+
+    date_published = ET.SubElement(dates, "date")
+    date_published.set("type", "Published")
+    date_published.text = "2026-05-11"
+
+    date_revised = ET.SubElement(dates, "date")
+    date_revised.set("type", "Revised")
+    date_revised.text = "2026-05-11"
+
+    # FEES
+    fees = ET.SubElement(root, "fees")
+    fees.text = "None. This dataset is open access under CC BY 4.0."
+
+    # ENCODING
+    encoding = ET.SubElement(root, "encoding")
+    encoding.text = "UTF-8"
+
+    # CRS
+    crs = ET.SubElement(root, "crs")
+    spatialrefsys = ET.SubElement(crs, "spatialrefsys")
+
+    crs_native = ET.SubElement(spatialrefsys, "nativeFormat")
+    crs_native.text = "Wkt"
+
+    crs_wkt = ET.SubElement(spatialrefsys, "wkt")
+    crs_wkt.text = meta["spatial"]["crs"].get("wkt", "")
+
+    crs_desc = ET.SubElement(spatialrefsys, "description")
+    crs_desc.text = meta["spatial"]["crs"]["name"]
+
+    crs_type = ET.SubElement(spatialrefsys, "type")
+    crs_type.text = "crs"
+
+    # EXTENT
+    extent = ET.SubElement(root, "extent")
+
+    # Spatial extent
+    spatial = ET.SubElement(extent, "spatial")
+    spatial.set("crs", meta["spatial"]["crs"]["name"])
+
+    bbox = meta["spatial"]["extent"]["bbox"]
+    if bbox and None not in bbox:
+        spatial.set("dimensions", "2")
+        spatial.set("minx", str(bbox[0]))
+        spatial.set("miny", str(bbox[1]))
+        spatial.set("maxx", str(bbox[2]))
+        spatial.set("maxy", str(bbox[3]))
+
+    # Temporal extent
+    temporal = ET.SubElement(extent, "temporal")
+    temp_start = ET.SubElement(temporal, "start")
+    temp_start.text = meta["acquisition"]["date_start"]
+    temp_end = ET.SubElement(temporal, "end")
+    temp_end.text = meta["acquisition"]["date_end"]
+
+    # Vertical extent (Z min/max)
+    vertical = ET.SubElement(extent, "vertical")
+    # We don't have actual Z min/max per city, but we can leave it empty or estimate
+    vert_min = ET.SubElement(vertical, "minimum")
+    vert_min.text = "0"
+    vert_max = ET.SubElement(vertical, "maximum")
+    vert_max.text = "0"
+    vert_unit = ET.SubElement(vertical, "unit")
+    vert_unit.text = "meters"
+
+    # CATEGORIES
+    categories = ET.SubElement(root, "categories")
+    cat = ET.SubElement(categories, "category")
+    cat.text = "Elevation"
+    cat2 = ET.SubElement(categories, "category")
+    cat2.text = "Geoscientific Information"
+
+    # KEYWORDS
+    keywords = ET.SubElement(root, "keywords")
+
+    # Add vocabulary attribute for GCMD
+    vocab = ET.SubElement(keywords, "vocabulary")
+    vocab.set("name", "GCMD")
+    vocab.text = "EARTH SCIENCE > LAND SURFACE > TOPOGRAPHY > TERRAIN ELEVATION > DIGITAL ELEVATION/TERRAIN MODEL (DEM)"
+
+    for kw in meta["fair"]["findable"]["keywords"]:
+        kw_el = ET.SubElement(keywords, "keyword")
+        kw_el.text = kw
+
+    # Add extra keywords
+    extra_kws = ["DSM", "local feature matching", "computer vision", "urban terrain"]
+    for kw in extra_kws:
+        kw_el = ET.SubElement(keywords, "keyword")
+        kw_el.text = kw
+
+    # RIGHTS
+    rights = ET.SubElement(root, "rights")
+    rights.text = f"{meta['fair']['reusable']['license']}. You are free to share and adapt under attribution terms."
+
+    # LICENSE
+    license_el = ET.SubElement(root, "license")
+    license_el.text = "Creative Commons Attribution 4.0 International (CC BY 4.0)"
+
+    # HISTORY
+    history = ET.SubElement(root, "history")
+    hist_entry = ET.SubElement(history, "history")
+    hist_entry.text = (
+        f"Dataset created from {meta['acquisition']['source']} data. "
+        f"Processed with PDAL {meta['processing']['software_version']}. "
+        f"Patch extraction: 333x333 pixels. "
+        f"Released as MatchGeo-DEM v1.1 on 2026-05-11."
+    )
+
+    # CONSTRAINTS
+    constraints = ET.SubElement(root, "constraints")
+
+    # Use constraints
+    use_constraints = ET.SubElement(constraints, "constraint")
+    use_constraints.set("type", "Use")
+    use_constraints.text = "Attribution required. See LICENSE file or https://creativecommons.org/licenses/by/4.0/"
+
+    # Access constraints
+    access_constraints = ET.SubElement(constraints, "constraint")
+    access_constraints.set("type", "Access")
+    access_constraints.text = "Open access. No registration required."
+
+    # Write QMD file
+    qmd_path = data_path / f"{location}/{location}.qmd"
+
+    # Pretty print XML
+    ET.indent(root, space="  ")
+    tree = ET.ElementTree(root)
+    tree.write(qmd_path, encoding="utf-8", xml_declaration=True)
+
+    print(f"\n✅ {location}: Written {qmd_path}")
+    print(f"   Title: {title.text[:50]}...")
+    print(f"   Contacts: 2 (Maintainer + Data Provider)")
+    print(f"   Links: 3+ (Source + DOI + License)")
+    print(f"   Dates: Created, Published, Revised")
+    print(f"   Categories: Elevation, Geoscientific Information")
+    print(f"   Keywords: {len(meta['fair']['findable']['keywords']) + 4} total")
+
+print("\n" + "=" * 70)
+print("Done! Each .tif now has a matching .qmd with COMPLETE metadata.")
+print("QGIS will auto-load the .qmd when you add the layer.")
+print("=" * 70)

splits/split_manifest.json

@@ -0,0 +1,19 @@
+{
+  "seed": 42,
+  "ratios": {
+    "train": 0.8,
+    "validation": 0.1,
+    "test": 0.1
+  },
+  "total_tiles": 27268,
+  "splits": {
+    "train": 21810,
+    "validation": 2722,
+    "test": 2736
+  },
+  "files": {
+    "train": "/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/splits/train.csv",
+    "validation": "/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/splits/validation.csv",
+    "test": "/home/sabrina/Documents/Tese/05_Dataset/MatchGeo-DEM-v1/splits/test.csv"
+  }
+}

stac/collection.json

@@ -0,0 +1,165 @@
+{
+  "type": "Collection",
+  "stac_version": "1.0.0",
+  "id": "matchgeo-dem-v1",
+  "title": "MatchGeo: Multi-region DEM Dataset for Local Feature Matching",
+  "description": "MatchGeo is a curated, multi-region Digital Elevation Model (DEM) dataset designed for training and benchmarking local feature matching algorithms in urban and natural terrain analysis. It aggregates high-resolution elevation data from 13 distinct environments across 6 continents.",
+  "license": "CC-BY-4.0",
+  "keywords": [
+    "DEM",
+    "DSM",
+    "elevation",
+    "local feature matching",
+    "computer vision",
+    "geospatial",
+    "LiDAR",
+    "photogrammetry"
+  ],
+  "providers": [
+    {
+      "name": "Correa, S. P. L. P.; Santos, A. de Paula; Oliveira, H. N.; Beltons, D.",
+      "roles": [
+        "producer",
+        "licensor"
+      ],
+      "url": "https://doi.org/10.5281/zenodo.21229785"
+    }
+  ],
+  "extent": {
+    "spatial": {
+      "bbox": [
+        [
+          -180,
+          -90,
+          180,
+          90
+        ]
+      ]
+    },
+    "temporal": {
+      "interval": [
+        [
+          "2011-01-01T00:00:00Z",
+          "2026-12-31T23:59:59Z"
+        ]
+      ]
+    }
+  },
+  "links": [
+    {
+      "rel": "self",
+      "href": "./collection.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "root",
+      "href": "./collection.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "license",
+      "href": "../LICENSE",
+      "type": "text/plain"
+    },
+    {
+      "rel": "cite-as",
+      "href": "https://doi.org/10.5281/zenodo.19339008",
+      "type": "text/html"
+    },
+    {
+      "rel": "item",
+      "href": "./items/ATA_MV.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "item",
+      "href": "./items/BRA_SP.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "item",
+      "href": "./items/CHN_WS.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "item",
+      "href": "./items/ESP_EH.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "item",
+      "href": "./items/FIN_LM.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "item",
+      "href": "./items/GER_BN.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "item",
+      "href": "./items/IDN_SV.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "item",
+      "href": "./items/KAZ_AC.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "item",
+      "href": "./items/KSA_WA.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "item",
+      "href": "./items/NAM_HF.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "item",
+      "href": "./items/NZL_KP.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "item",
+      "href": "./items/PHL_TA.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "item",
+      "href": "./items/USA_GC.json",
+      "type": "application/json"
+    }
+  ],
+  "summaries": {
+    "gsd": [
+      0.5,
+      0.53,
+      0.87,
+      1.0,
+      1.6,
+      2.0,
+      10.0
+    ],
+    "eo:bands": [
+      {
+        "name": "elevation",
+        "common_name": "elevation",
+        "unit": "meter"
+      }
+    ]
+  },
+  "assets": {
+    "manifest": {
+      "href": "../manifest.json",
+      "type": "application/json",
+      "title": "Central dataset manifest (JSON-LD)"
+    },
+    "dataset_description": {
+      "href": "../DATASET_DESCRIPTION.md",
+      "type": "text/markdown",
+      "title": "FAIR-compliant dataset description"
+    }
+  }
+}

stac/items/ATA_MV.json

@@ -0,0 +1,120 @@
+{
+  "type": "Feature",
+  "stac_version": "1.0.0",
+  "id": "ATA_MV",
+  "collection": "matchgeo-dem-v1",
+  "bbox": [
+    -750100.0,
+    -1250100.0,
+    -699900.0,
+    -1199900.0
+  ],
+  "geometry": {
+    "type": "Polygon",
+    "coordinates": [
+      [
+        [
+          -699900.0,
+          -1250100.0
+        ],
+        [
+          -699900.0,
+          -1199900.0
+        ],
+        [
+          -750100.0,
+          -1199900.0
+        ],
+        [
+          -750100.0,
+          -1250100.0
+        ],
+        [
+          -699900.0,
+          -1250100.0
+        ]
+      ]
+    ]
+  },
+  "properties": {
+    "title": "Mount Athos, Greece",
+    "description": "Mount Athos, Greece \u2014 satellite_insar at 1.0 m resolution",
+    "datetime": "2011-01-01T00:00:00Z",
+    "start_datetime": "2011-01-01T00:00:00Z",
+    "end_datetime": "2015-12-31T23:59:59Z",
+    "providers": [
+      {
+        "name": "Copernicus DEM",
+        "roles": [
+          "producer"
+        ]
+      }
+    ],
+    "gsd": 1.0,
+    "proj:epsg": 3031,
+    "matchgeo:method": "satellite_insar",
+    "matchgeo:n_tiles": 5625,
+    "matchgeo:labelled": false,
+    "matchgeo:has_annotations": false,
+    "proj:wkt2": "PROJCS[\"WGS 84 / Antarctic Polar Stereographic\",GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]],PROJECTION[\"Polar_Stereographic\"],PARAMETER[\"latitude_of_origin\",-71],PARAMETER[\"central_meridian\",0],PARAMETER[\"false_easting\",0],PARAMETER[\"false_northing\",0],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Easting\",NORTH],AXIS[\"Northing\",NORTH],AUTHORITY[\"EPSG\",\"3031\"]]"
+  },
+  "assets": {
+    "dem": {
+      "href": "data/ATA_MV/ATA_MV.tif",
+      "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+      "title": "Merged DEM \u2014 ATA_MV",
+      "roles": [
+        "data"
+      ],
+      "eo:bands": [
+        {
+          "name": "elevation",
+          "common_name": "elevation",
+          "unit": "meter"
+        }
+      ]
+    },
+    "tiles": {
+      "href": "data/ATA_MV/tiles/",
+      "type": "application/x-geotiff-tiles",
+      "title": "333\u00d7333 pixel tiles \u2014 ATA_MV",
+      "roles": [
+        "data"
+      ],
+      "x-asset-count": 5625
+    },
+    "extent": {
+      "href": "data/ATA_MV/ATA_MV_extent.geojson",
+      "type": "application/geo+json",
+      "title": "Coverage extent polygon",
+      "roles": [
+        "metadata"
+      ]
+    },
+    "tile_index": {
+      "href": "data/ATA_MV/ATA_MV_tiles.geojson",
+      "type": "application/geo+json",
+      "title": "Tile index (grid)",
+      "roles": [
+        "metadata"
+      ]
+    }
+  },
+  "links": [
+    {
+      "rel": "self",
+      "href": "./ATA_MV.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "collection",
+      "href": "../collection.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "root",
+      "href": "../collection.json",
+      "type": "application/json"
+    }
+  ]
+}

stac/items/BRA_SP.json

@@ -0,0 +1,120 @@
+{
+  "type": "Feature",
+  "stac_version": "1.0.0",
+  "id": "BRA_SP",
+  "collection": "matchgeo-dem-v1",
+  "bbox": [
+    331461.943,
+    7390840.954,
+    335291.443,
+    7395003.454
+  ],
+  "geometry": {
+    "type": "Polygon",
+    "coordinates": [
+      [
+        [
+          335291.443,
+          7390840.954
+        ],
+        [
+          335291.443,
+          7395003.454
+        ],
+        [
+          331461.943,
+          7395003.454
+        ],
+        [
+          331461.943,
+          7390840.954
+        ],
+        [
+          335291.443,
+          7390840.954
+        ]
+      ]
+    ]
+  },
+  "properties": {
+    "title": "S\u00e3o Paulo, Brazil",
+    "description": "S\u00e3o Paulo, Brazil \u2014 airborne_lidar at 0.5 m resolution",
+    "datetime": "2020-01-01T00:00:00Z",
+    "start_datetime": "2020-01-01T00:00:00Z",
+    "end_datetime": "2020-12-31T23:59:59Z",
+    "providers": [
+      {
+        "name": "GeoSampa",
+        "roles": [
+          "producer"
+        ]
+      }
+    ],
+    "gsd": 0.5,
+    "proj:epsg": 31983,
+    "matchgeo:method": "airborne_lidar",
+    "matchgeo:n_tiles": 558,
+    "matchgeo:labelled": true,
+    "matchgeo:has_annotations": false,
+    "proj:wkt2": "PROJCS[\"SIRGAS 2000 / UTM zone 23S\",GEOGCS[\"SIRGAS 2000\",DATUM[\"Sistema_de_Referencia_Geocentrico_para_las_AmericaS_2000\",SPHEROID[\"GRS 1980\",6378137,298.257222101,AUTHORITY[\"EPSG\",\"7019\"]],AUTHORITY[\"EPSG\",\"6674\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4674\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",-45],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",10000000],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH],AUTHORITY[\"EPSG\",\"31983\"]]"
+  },
+  "assets": {
+    "dem": {
+      "href": "data/BRA_SP/BRA_SP.tif",
+      "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+      "title": "Merged DEM \u2014 BRA_SP",
+      "roles": [
+        "data"
+      ],
+      "eo:bands": [
+        {
+          "name": "elevation",
+          "common_name": "elevation",
+          "unit": "meter"
+        }
+      ]
+    },
+    "tiles": {
+      "href": "data/BRA_SP/tiles/",
+      "type": "application/x-geotiff-tiles",
+      "title": "333\u00d7333 pixel tiles \u2014 BRA_SP",
+      "roles": [
+        "data"
+      ],
+      "x-asset-count": 558
+    },
+    "extent": {
+      "href": "data/BRA_SP/BRA_SP_extent.geojson",
+      "type": "application/geo+json",
+      "title": "Coverage extent polygon",
+      "roles": [
+        "metadata"
+      ]
+    },
+    "tile_index": {
+      "href": "data/BRA_SP/BRA_SP_tiles.geojson",
+      "type": "application/geo+json",
+      "title": "Tile index (grid)",
+      "roles": [
+        "metadata"
+      ]
+    }
+  },
+  "links": [
+    {
+      "rel": "self",
+      "href": "./BRA_SP.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "collection",
+      "href": "../collection.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "root",
+      "href": "../collection.json",
+      "type": "application/json"
+    }
+  ]
+}

stac/items/CHN_WS.json

@@ -0,0 +1,120 @@
+{
+  "type": "Feature",
+  "stac_version": "1.0.0",
+  "id": "CHN_WS",
+  "collection": "matchgeo-dem-v1",
+  "bbox": [
+    682352.9987419512,
+    4299757.372692683,
+    693209.5152152042,
+    4309501.813966408
+  ],
+  "geometry": {
+    "type": "Polygon",
+    "coordinates": [
+      [
+        [
+          693209.5152152042,
+          4299757.372692683
+        ],
+        [
+          693209.5152152042,
+          4309501.813966408
+        ],
+        [
+          682352.9987419512,
+          4309501.813966408
+        ],
+        [
+          682352.9987419512,
+          4299757.372692683
+        ],
+        [
+          693209.5152152042,
+          4299757.372692683
+        ]
+      ]
+    ]
+  },
+  "properties": {
+    "title": "Wutai Shan, China",
+    "description": "Wutai Shan, China \u2014 uav_sfm at 1.0 m resolution",
+    "datetime": "2021-01-01T00:00:00Z",
+    "start_datetime": "2021-01-01T00:00:00Z",
+    "end_datetime": "2021-12-31T23:59:59Z",
+    "providers": [
+      {
+        "name": "OpenTopography",
+        "roles": [
+          "producer"
+        ]
+      }
+    ],
+    "gsd": 1.0,
+    "proj:epsg": 32649,
+    "matchgeo:method": "uav_sfm",
+    "matchgeo:n_tiles": 1076,
+    "matchgeo:labelled": false,
+    "matchgeo:has_annotations": false,
+    "proj:wkt2": "PROJCS[\"WGS 84 / UTM zone 49N\",GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",111],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH],AUTHORITY[\"EPSG\",\"32649\"]]"
+  },
+  "assets": {
+    "dem": {
+      "href": "data/CHN_WS/CHN_WS.tif",
+      "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+      "title": "Merged DEM \u2014 CHN_WS",
+      "roles": [
+        "data"
+      ],
+      "eo:bands": [
+        {
+          "name": "elevation",
+          "common_name": "elevation",
+          "unit": "meter"
+        }
+      ]
+    },
+    "tiles": {
+      "href": "data/CHN_WS/tiles/",
+      "type": "application/x-geotiff-tiles",
+      "title": "333\u00d7333 pixel tiles \u2014 CHN_WS",
+      "roles": [
+        "data"
+      ],
+      "x-asset-count": 1076
+    },
+    "extent": {
+      "href": "data/CHN_WS/CHN_WS_extent.geojson",
+      "type": "application/geo+json",
+      "title": "Coverage extent polygon",
+      "roles": [
+        "metadata"
+      ]
+    },
+    "tile_index": {
+      "href": "data/CHN_WS/CHN_WS_tiles.geojson",
+      "type": "application/geo+json",
+      "title": "Tile index (grid)",
+      "roles": [
+        "metadata"
+      ]
+    }
+  },
+  "links": [
+    {
+      "rel": "self",
+      "href": "./CHN_WS.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "collection",
+      "href": "../collection.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "root",
+      "href": "../collection.json",
+      "type": "application/json"
+    }
+  ]
+}

stac/items/ESP_EH.json

@@ -0,0 +1,120 @@
+{
+  "type": "Feature",
+  "stac_version": "1.0.0",
+  "id": "ESP_EH",
+  "collection": "matchgeo-dem-v1",
+  "bbox": [
+    200180.0,
+    3075630.0,
+    216940.0,
+    3085180.0
+  ],
+  "geometry": {
+    "type": "Polygon",
+    "coordinates": [
+      [
+        [
+          216940.0,
+          3075630.0
+        ],
+        [
+          216940.0,
+          3085180.0
+        ],
+        [
+          200180.0,
+          3085180.0
+        ],
+        [
+          200180.0,
+          3075630.0
+        ],
+        [
+          216940.0,
+          3075630.0
+        ]
+      ]
+    ]
+  },
+  "properties": {
+    "title": "El Hierro, Spain",
+    "description": "El Hierro, Spain \u2014 airborne_lidar at 1.0 m resolution",
+    "datetime": "2022-01-01T00:00:00Z",
+    "start_datetime": "2022-01-01T00:00:00Z",
+    "end_datetime": "2025-12-31T23:59:59Z",
+    "providers": [
+      {
+        "name": "PNOA-LiDAR",
+        "roles": [
+          "producer"
+        ]
+      }
+    ],
+    "gsd": 1.0,
+    "proj:epsg": 3040,
+    "matchgeo:method": "airborne_lidar",
+    "matchgeo:n_tiles": 2460,
+    "matchgeo:labelled": false,
+    "matchgeo:has_annotations": false,
+    "proj:wkt2": "PROJCS[\"ETRS89 / UTM zone 28N (N-E)\",GEOGCS[\"ETRS89\",DATUM[\"European_Terrestrial_Reference_System_1989\",SPHEROID[\"GRS 1980\",6378137,298.257222101,AUTHORITY[\"EPSG\",\"7019\"]],AUTHORITY[\"EPSG\",\"6258\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4258\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",-15],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Northing\",NORTH],AXIS[\"Easting\",EAST],AUTHORITY[\"EPSG\",\"3040\"]]"
+  },
+  "assets": {
+    "dem": {
+      "href": "data/ESP_EH/ESP_EH.tif",
+      "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+      "title": "Merged DEM \u2014 ESP_EH",
+      "roles": [
+        "data"
+      ],
+      "eo:bands": [
+        {
+          "name": "elevation",
+          "common_name": "elevation",
+          "unit": "meter"
+        }
+      ]
+    },
+    "tiles": {
+      "href": "data/ESP_EH/tiles/",
+      "type": "application/x-geotiff-tiles",
+      "title": "333\u00d7333 pixel tiles \u2014 ESP_EH",
+      "roles": [
+        "data"
+      ],
+      "x-asset-count": 2460
+    },
+    "extent": {
+      "href": "data/ESP_EH/ESP_EH_extent.geojson",
+      "type": "application/geo+json",
+      "title": "Coverage extent polygon",
+      "roles": [
+        "metadata"
+      ]
+    },
+    "tile_index": {
+      "href": "data/ESP_EH/ESP_EH_tiles.geojson",
+      "type": "application/geo+json",
+      "title": "Tile index (grid)",
+      "roles": [
+        "metadata"
+      ]
+    }
+  },
+  "links": [
+    {
+      "rel": "self",
+      "href": "./ESP_EH.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "collection",
+      "href": "../collection.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "root",
+      "href": "../collection.json",
+      "type": "application/json"
+    }
+  ]
+}

stac/items/FIN_LM.json

@@ -0,0 +1,120 @@
+{
+  "type": "Feature",
+  "stac_version": "1.0.0",
+  "id": "FIN_LM",
+  "collection": "matchgeo-dem-v1",
+  "bbox": [
+    498760.0,
+    7735520.0,
+    503624.0,
+    7755680.0
+  ],
+  "geometry": {
+    "type": "Polygon",
+    "coordinates": [
+      [
+        [
+          503624.0,
+          7735520.0
+        ],
+        [
+          503624.0,
+          7755680.0
+        ],
+        [
+          498760.0,
+          7755680.0
+        ],
+        [
+          498760.0,
+          7735520.0
+        ],
+        [
+          503624.0,
+          7735520.0
+        ]
+      ]
+    ]
+  },
+  "properties": {
+    "title": "Lahti, Finland",
+    "description": "Lahti, Finland \u2014 airborne_lidar_photogrammetry at 2.0 m resolution",
+    "datetime": "2020-01-01T00:00:00Z",
+    "start_datetime": "2020-01-01T00:00:00Z",
+    "end_datetime": "2026-12-31T23:59:59Z",
+    "providers": [
+      {
+        "name": "National Land Survey of Finland",
+        "roles": [
+          "producer"
+        ]
+      }
+    ],
+    "gsd": 2.0,
+    "proj:epsg": 3067,
+    "matchgeo:method": "airborne_lidar_photogrammetry",
+    "matchgeo:n_tiles": 248,
+    "matchgeo:labelled": false,
+    "matchgeo:has_annotations": false,
+    "proj:wkt2": "PROJCS[\"EUREF-FIN / TM35FIN(E,N)\",GEOGCS[\"EUREF-FIN\",DATUM[\"EUREF-FIN\",SPHEROID[\"GRS 1980\",6378137,298.257222101,AUTHORITY[\"EPSG\",\"7019\"]],AUTHORITY[\"EPSG\",\"1391\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"10690\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",27],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH],AUTHORITY[\"EPSG\",\"3067\"]]"
+  },
+  "assets": {
+    "dem": {
+      "href": "data/FIN_LM/FIN_LM.tif",
+      "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+      "title": "Merged DEM \u2014 FIN_LM",
+      "roles": [
+        "data"
+      ],
+      "eo:bands": [
+        {
+          "name": "elevation",
+          "common_name": "elevation",
+          "unit": "meter"
+        }
+      ]
+    },
+    "tiles": {
+      "href": "data/FIN_LM/tiles/",
+      "type": "application/x-geotiff-tiles",
+      "title": "333\u00d7333 pixel tiles \u2014 FIN_LM",
+      "roles": [
+        "data"
+      ],
+      "x-asset-count": 248
+    },
+    "extent": {
+      "href": "data/FIN_LM/FIN_LM_extent.geojson",
+      "type": "application/geo+json",
+      "title": "Coverage extent polygon",
+      "roles": [
+        "metadata"
+      ]
+    },
+    "tile_index": {
+      "href": "data/FIN_LM/FIN_LM_tiles.geojson",
+      "type": "application/geo+json",
+      "title": "Tile index (grid)",
+      "roles": [
+        "metadata"
+      ]
+    }
+  },
+  "links": [
+    {
+      "rel": "self",
+      "href": "./FIN_LM.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "collection",
+      "href": "../collection.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "root",
+      "href": "../collection.json",
+      "type": "application/json"
+    }
+  ]
+}

stac/items/GER_BN.json

@@ -0,0 +1,128 @@
+{
+  "type": "Feature",
+  "stac_version": "1.0.0",
+  "id": "GER_BN",
+  "collection": "matchgeo-dem-v1",
+  "bbox": [
+    360004.0,
+    5610033.0,
+    367996.0,
+    5626998.0
+  ],
+  "geometry": {
+    "type": "Polygon",
+    "coordinates": [
+      [
+        [
+          367996.0,
+          5610033.0
+        ],
+        [
+          367996.0,
+          5626998.0
+        ],
+        [
+          360004.0,
+          5626998.0
+        ],
+        [
+          360004.0,
+          5610033.0
+        ],
+        [
+          367996.0,
+          5610033.0
+        ]
+      ]
+    ]
+  },
+  "properties": {
+    "title": "Bonn, Germany",
+    "description": "Bonn, Germany \u2014 airborne_lidar at 1.0 m resolution",
+    "datetime": "2016-01-01T00:00:00Z",
+    "start_datetime": "2016-01-01T00:00:00Z",
+    "end_datetime": "2018-12-31T23:59:59Z",
+    "providers": [
+      {
+        "name": "Geobasis NRW",
+        "roles": [
+          "producer"
+        ]
+      }
+    ],
+    "gsd": 1.0,
+    "proj:epsg": 25832,
+    "matchgeo:method": "airborne_lidar",
+    "matchgeo:n_tiles": 1759,
+    "matchgeo:labelled": true,
+    "matchgeo:has_annotations": true,
+    "proj:wkt2": "LOCAL_CS[\"ETRS89 / UTM zone 32N + DHHN92 height\",UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH]]"
+  },
+  "assets": {
+    "dem": {
+      "href": "data/GER_BN/GER_BN.tif",
+      "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+      "title": "Merged DEM \u2014 GER_BN",
+      "roles": [
+        "data"
+      ],
+      "eo:bands": [
+        {
+          "name": "elevation",
+          "common_name": "elevation",
+          "unit": "meter"
+        }
+      ]
+    },
+    "tiles": {
+      "href": "data/GER_BN/tiles/",
+      "type": "application/x-geotiff-tiles",
+      "title": "333\u00d7333 pixel tiles \u2014 GER_BN",
+      "roles": [
+        "data"
+      ],
+      "x-asset-count": 1759
+    },
+    "extent": {
+      "href": "data/GER_BN/GER_BN_extent.geojson",
+      "type": "application/geo+json",
+      "title": "Coverage extent polygon",
+      "roles": [
+        "metadata"
+      ]
+    },
+    "tile_index": {
+      "href": "data/GER_BN/GER_BN_tiles.geojson",
+      "type": "application/geo+json",
+      "title": "Tile index (grid)",
+      "roles": [
+        "metadata"
+      ]
+    },
+    "annotations": {
+      "href": "data/GER_BN/annotations/",
+      "type": "application/json",
+      "title": "Keypoint annotations",
+      "roles": [
+        "metadata"
+      ]
+    }
+  },
+  "links": [
+    {
+      "rel": "self",
+      "href": "./GER_BN.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "collection",
+      "href": "../collection.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "root",
+      "href": "../collection.json",
+      "type": "application/json"
+    }
+  ]
+}

stac/items/IDN_SV.json

@@ -0,0 +1,120 @@
+{
+  "type": "Feature",
+  "stac_version": "1.0.0",
+  "id": "IDN_SV",
+  "collection": "matchgeo-dem-v1",
+  "bbox": [
+    432288.2209851263,
+    347430.19815381255,
+    436376.7231951263,
+    351748.91844681255
+  ],
+  "geometry": {
+    "type": "Polygon",
+    "coordinates": [
+      [
+        [
+          436376.7231951263,
+          347430.19815381255
+        ],
+        [
+          436376.7231951263,
+          351748.91844681255
+        ],
+        [
+          432288.2209851263,
+          351748.91844681255
+        ],
+        [
+          432288.2209851263,
+          347430.19815381255
+        ],
+        [
+          436376.7231951263,
+          347430.19815381255
+        ]
+      ]
+    ]
+  },
+  "properties": {
+    "title": "Sinabung Volcano, Indonesia",
+    "description": "Sinabung Volcano, Indonesia \u2014 uas_sfm at 0.87 m resolution",
+    "datetime": "2018-01-01T00:00:00Z",
+    "start_datetime": "2018-01-01T00:00:00Z",
+    "end_datetime": "2018-12-31T23:59:59Z",
+    "providers": [
+      {
+        "name": "OpenTopography",
+        "roles": [
+          "producer"
+        ]
+      }
+    ],
+    "gsd": 0.87,
+    "proj:epsg": 32647,
+    "matchgeo:method": "uas_sfm",
+    "matchgeo:n_tiles": 181,
+    "matchgeo:labelled": false,
+    "matchgeo:has_annotations": false,
+    "proj:wkt2": "PROJCS[\"WGS 84 / UTM zone 47N\",GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",99],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH],AUTHORITY[\"EPSG\",\"32647\"]]"
+  },
+  "assets": {
+    "dem": {
+      "href": "data/IDN_SV/IDN_SV.tif",
+      "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+      "title": "Merged DEM \u2014 IDN_SV",
+      "roles": [
+        "data"
+      ],
+      "eo:bands": [
+        {
+          "name": "elevation",
+          "common_name": "elevation",
+          "unit": "meter"
+        }
+      ]
+    },
+    "tiles": {
+      "href": "data/IDN_SV/tiles/",
+      "type": "application/x-geotiff-tiles",
+      "title": "333\u00d7333 pixel tiles \u2014 IDN_SV",
+      "roles": [
+        "data"
+      ],
+      "x-asset-count": 181
+    },
+    "extent": {
+      "href": "data/IDN_SV/IDN_SV_extent.geojson",
+      "type": "application/geo+json",
+      "title": "Coverage extent polygon",
+      "roles": [
+        "metadata"
+      ]
+    },
+    "tile_index": {
+      "href": "data/IDN_SV/IDN_SV_tiles.geojson",
+      "type": "application/geo+json",
+      "title": "Tile index (grid)",
+      "roles": [
+        "metadata"
+      ]
+    }
+  },
+  "links": [
+    {
+      "rel": "self",
+      "href": "./IDN_SV.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "collection",
+      "href": "../collection.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "root",
+      "href": "../collection.json",
+      "type": "application/json"
+    }
+  ]
+}

stac/items/KAZ_AC.json

@@ -0,0 +1,120 @@
+{
+  "type": "Feature",
+  "stac_version": "1.0.0",
+  "id": "KAZ_AC",
+  "collection": "matchgeo-dem-v1",
+  "bbox": [
+    648000.0,
+    4781815.5,
+    665137.5,
+    4796253.0
+  ],
+  "geometry": {
+    "type": "Polygon",
+    "coordinates": [
+      [
+        [
+          665137.5,
+          4781815.5
+        ],
+        [
+          665137.5,
+          4796253.0
+        ],
+        [
+          648000.0,
+          4796253.0
+        ],
+        [
+          648000.0,
+          4781815.5
+        ],
+        [
+          665137.5,
+          4781815.5
+        ]
+      ]
+    ]
+  },
+  "properties": {
+    "title": "Almaty City, Kazakhstan",
+    "description": "Almaty City, Kazakhstan \u2014 satellite_stereophotogrammetry at 1.0 m resolution",
+    "datetime": "2017-01-01T00:00:00Z",
+    "start_datetime": "2017-01-01T00:00:00Z",
+    "end_datetime": "2017-12-31T23:59:59Z",
+    "providers": [
+      {
+        "name": "OpenTopography",
+        "roles": [
+          "producer"
+        ]
+      }
+    ],
+    "gsd": 1.0,
+    "proj:epsg": 32643,
+    "matchgeo:method": "satellite_stereophotogrammetry",
+    "matchgeo:n_tiles": 887,
+    "matchgeo:labelled": false,
+    "matchgeo:has_annotations": false,
+    "proj:wkt2": "PROJCS[\"WGS 84 / UTM zone 43N\",GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",75],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH],AUTHORITY[\"EPSG\",\"32643\"]]"
+  },
+  "assets": {
+    "dem": {
+      "href": "data/KAZ_AC/KAZ_AC.tif",
+      "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+      "title": "Merged DEM \u2014 KAZ_AC",
+      "roles": [
+        "data"
+      ],
+      "eo:bands": [
+        {
+          "name": "elevation",
+          "common_name": "elevation",
+          "unit": "meter"
+        }
+      ]
+    },
+    "tiles": {
+      "href": "data/KAZ_AC/tiles/",
+      "type": "application/x-geotiff-tiles",
+      "title": "333\u00d7333 pixel tiles \u2014 KAZ_AC",
+      "roles": [
+        "data"
+      ],
+      "x-asset-count": 887
+    },
+    "extent": {
+      "href": "data/KAZ_AC/KAZ_AC_extent.geojson",
+      "type": "application/geo+json",
+      "title": "Coverage extent polygon",
+      "roles": [
+        "metadata"
+      ]
+    },
+    "tile_index": {
+      "href": "data/KAZ_AC/KAZ_AC_tiles.geojson",
+      "type": "application/geo+json",
+      "title": "Tile index (grid)",
+      "roles": [
+        "metadata"
+      ]
+    }
+  },
+  "links": [
+    {
+      "rel": "self",
+      "href": "./KAZ_AC.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "collection",
+      "href": "../collection.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "root",
+      "href": "../collection.json",
+      "type": "application/json"
+    }
+  ]
+}

stac/items/KSA_WA.json

@@ -0,0 +1,120 @@
+{
+  "type": "Feature",
+  "stac_version": "1.0.0",
+  "id": "KSA_WA",
+  "collection": "matchgeo-dem-v1",
+  "bbox": [
+    262997.6,
+    3069687.2,
+    291007.2,
+    3114711.2
+  ],
+  "geometry": {
+    "type": "Polygon",
+    "coordinates": [
+      [
+        [
+          291007.2,
+          3069687.2
+        ],
+        [
+          291007.2,
+          3114711.2
+        ],
+        [
+          262997.6,
+          3114711.2
+        ],
+        [
+          262997.6,
+          3069687.2
+        ],
+        [
+          291007.2,
+          3069687.2
+        ]
+      ]
+    ]
+  },
+  "properties": {
+    "title": "Wadi Al-Akhdar, Saudi Arabia",
+    "description": "Wadi Al-Akhdar, Saudi Arabia \u2014 satellite_stereophotogrammetry at 1.6 m resolution",
+    "datetime": "2016-01-01T00:00:00Z",
+    "start_datetime": "2016-01-01T00:00:00Z",
+    "end_datetime": "2016-12-31T23:59:59Z",
+    "providers": [
+      {
+        "name": "OpenTopography",
+        "roles": [
+          "producer"
+        ]
+      }
+    ],
+    "gsd": 1.6,
+    "proj:epsg": 32637,
+    "matchgeo:method": "satellite_stereophotogrammetry",
+    "matchgeo:n_tiles": 3880,
+    "matchgeo:labelled": false,
+    "matchgeo:has_annotations": false,
+    "proj:wkt2": "PROJCS[\"WGS 84 / UTM zone 37N\",GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",39],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH],AUTHORITY[\"EPSG\",\"32637\"]]"
+  },
+  "assets": {
+    "dem": {
+      "href": "data/KSA_WA/KSA_WA.tif",
+      "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+      "title": "Merged DEM \u2014 KSA_WA",
+      "roles": [
+        "data"
+      ],
+      "eo:bands": [
+        {
+          "name": "elevation",
+          "common_name": "elevation",
+          "unit": "meter"
+        }
+      ]
+    },
+    "tiles": {
+      "href": "data/KSA_WA/tiles/",
+      "type": "application/x-geotiff-tiles",
+      "title": "333\u00d7333 pixel tiles \u2014 KSA_WA",
+      "roles": [
+        "data"
+      ],
+      "x-asset-count": 3880
+    },
+    "extent": {
+      "href": "data/KSA_WA/KSA_WA_extent.geojson",
+      "type": "application/geo+json",
+      "title": "Coverage extent polygon",
+      "roles": [
+        "metadata"
+      ]
+    },
+    "tile_index": {
+      "href": "data/KSA_WA/KSA_WA_tiles.geojson",
+      "type": "application/geo+json",
+      "title": "Tile index (grid)",
+      "roles": [
+        "metadata"
+      ]
+    }
+  },
+  "links": [
+    {
+      "rel": "self",
+      "href": "./KSA_WA.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "collection",
+      "href": "../collection.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "root",
+      "href": "../collection.json",
+      "type": "application/json"
+    }
+  ]
+}

stac/items/NAM_HF.json

@@ -0,0 +1,120 @@
+{
+  "type": "Feature",
+  "stac_version": "1.0.0",
+  "id": "NAM_HF",
+  "collection": "matchgeo-dem-v1",
+  "bbox": [
+    589837.6021,
+    7278647.9482,
+    601054.1875,
+    7285555.4766
+  ],
+  "geometry": {
+    "type": "Polygon",
+    "coordinates": [
+      [
+        [
+          601054.1875,
+          7278647.9482
+        ],
+        [
+          601054.1875,
+          7285555.4766
+        ],
+        [
+          589837.6021,
+          7285555.4766
+        ],
+        [
+          589837.6021,
+          7278647.9482
+        ],
+        [
+          601054.1875,
+          7278647.9482
+        ]
+      ]
+    ]
+  },
+  "properties": {
+    "title": "Hebron Fault, Namibia",
+    "description": "Hebron Fault, Namibia \u2014 satellite_stereophotogrammetry at 0.53 m resolution",
+    "datetime": "2017-01-01T00:00:00Z",
+    "start_datetime": "2017-01-01T00:00:00Z",
+    "end_datetime": "2017-12-31T23:59:59Z",
+    "providers": [
+      {
+        "name": "OpenTopography",
+        "roles": [
+          "producer"
+        ]
+      }
+    ],
+    "gsd": 0.53,
+    "proj:epsg": 32733,
+    "matchgeo:method": "satellite_stereophotogrammetry",
+    "matchgeo:n_tiles": 1457,
+    "matchgeo:labelled": false,
+    "matchgeo:has_annotations": false,
+    "proj:wkt2": "PROJCS[\"WGS 84 / UTM zone 33S\",GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",15],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",10000000],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH],AUTHORITY[\"EPSG\",\"32733\"]]"
+  },
+  "assets": {
+    "dem": {
+      "href": "data/NAM_HF/NAM_HF.tif",
+      "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+      "title": "Merged DEM \u2014 NAM_HF",
+      "roles": [
+        "data"
+      ],
+      "eo:bands": [
+        {
+          "name": "elevation",
+          "common_name": "elevation",
+          "unit": "meter"
+        }
+      ]
+    },
+    "tiles": {
+      "href": "data/NAM_HF/tiles/",
+      "type": "application/x-geotiff-tiles",
+      "title": "333\u00d7333 pixel tiles \u2014 NAM_HF",
+      "roles": [
+        "data"
+      ],
+      "x-asset-count": 1457
+    },
+    "extent": {
+      "href": "data/NAM_HF/NAM_HF_extent.geojson",
+      "type": "application/geo+json",
+      "title": "Coverage extent polygon",
+      "roles": [
+        "metadata"
+      ]
+    },
+    "tile_index": {
+      "href": "data/NAM_HF/NAM_HF_tiles.geojson",
+      "type": "application/geo+json",
+      "title": "Tile index (grid)",
+      "roles": [
+        "metadata"
+      ]
+    }
+  },
+  "links": [
+    {
+      "rel": "self",
+      "href": "./NAM_HF.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "collection",
+      "href": "../collection.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "root",
+      "href": "../collection.json",
+      "type": "application/json"
+    }
+  ]
+}

stac/items/NZL_KP.json

@@ -0,0 +1,120 @@
+{
+  "type": "Feature",
+  "stac_version": "1.0.0",
+  "id": "NZL_KP",
+  "collection": "matchgeo-dem-v1",
+  "bbox": [
+    1547434.000000006,
+    5467239.00000001,
+    1563324.0000000063,
+    5479544.00000001
+  ],
+  "geometry": {
+    "type": "Polygon",
+    "coordinates": [
+      [
+        [
+          1563324.0000000063,
+          5467239.00000001
+        ],
+        [
+          1563324.0000000063,
+          5479544.00000001
+        ],
+        [
+          1547434.000000006,
+          5479544.00000001
+        ],
+        [
+          1547434.000000006,
+          5467239.00000001
+        ],
+        [
+          1563324.0000000063,
+          5467239.00000001
+        ]
+      ]
+    ]
+  },
+  "properties": {
+    "title": "Kapiti Coast, New Zealand",
+    "description": "Kapiti Coast, New Zealand \u2014 airborne_lidar at 1.0 m resolution",
+    "datetime": "2010-01-01T00:00:00Z",
+    "start_datetime": "2010-01-01T00:00:00Z",
+    "end_datetime": "2025-12-31T23:59:59Z",
+    "providers": [
+      {
+        "name": "LINZ",
+        "roles": [
+          "producer"
+        ]
+      }
+    ],
+    "gsd": 1.0,
+    "proj:epsg": 2193,
+    "matchgeo:method": "airborne_lidar",
+    "matchgeo:n_tiles": 1776,
+    "matchgeo:labelled": false,
+    "matchgeo:has_annotations": false,
+    "proj:wkt2": "PROJCS[\"NZGD2000 / New Zealand Transverse Mercator 2000\",GEOGCS[\"NZGD2000\",DATUM[\"New_Zealand_Geodetic_Datum_2000\",SPHEROID[\"GRS 1980\",6378137,298.257222101,AUTHORITY[\"EPSG\",\"7019\"]],AUTHORITY[\"EPSG\",\"6167\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4167\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",173],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",1600000],PARAMETER[\"false_northing\",10000000],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Northing\",NORTH],AXIS[\"Easting\",EAST],AUTHORITY[\"EPSG\",\"2193\"]]"
+  },
+  "assets": {
+    "dem": {
+      "href": "data/NZL_KP/NZL_KP.tif",
+      "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+      "title": "Merged DEM \u2014 NZL_KP",
+      "roles": [
+        "data"
+      ],
+      "eo:bands": [
+        {
+          "name": "elevation",
+          "common_name": "elevation",
+          "unit": "meter"
+        }
+      ]
+    },
+    "tiles": {
+      "href": "data/NZL_KP/tiles/",
+      "type": "application/x-geotiff-tiles",
+      "title": "333\u00d7333 pixel tiles \u2014 NZL_KP",
+      "roles": [
+        "data"
+      ],
+      "x-asset-count": 1776
+    },
+    "extent": {
+      "href": "data/NZL_KP/NZL_KP_extent.geojson",
+      "type": "application/geo+json",
+      "title": "Coverage extent polygon",
+      "roles": [
+        "metadata"
+      ]
+    },
+    "tile_index": {
+      "href": "data/NZL_KP/NZL_KP_tiles.geojson",
+      "type": "application/geo+json",
+      "title": "Tile index (grid)",
+      "roles": [
+        "metadata"
+      ]
+    }
+  },
+  "links": [
+    {
+      "rel": "self",
+      "href": "./NZL_KP.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "collection",
+      "href": "../collection.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "root",
+      "href": "../collection.json",
+      "type": "application/json"
+    }
+  ]
+}

stac/items/PHL_TA.json

@@ -0,0 +1,120 @@
+{
+  "type": "Feature",
+  "stac_version": "1.0.0",
+  "id": "PHL_TA",
+  "collection": "matchgeo-dem-v1",
+  "bbox": [
+    273003.0,
+    1544128.0,
+    276571.0,
+    1552546.0
+  ],
+  "geometry": {
+    "type": "Polygon",
+    "coordinates": [
+      [
+        [
+          276571.0,
+          1544128.0
+        ],
+        [
+          276571.0,
+          1552546.0
+        ],
+        [
+          273003.0,
+          1552546.0
+        ],
+        [
+          273003.0,
+          1544128.0
+        ],
+        [
+          276571.0,
+          1544128.0
+        ]
+      ]
+    ]
+  },
+  "properties": {
+    "title": "Tarlac, Philippines",
+    "description": "Tarlac, Philippines \u2014 airborne_lidar at 1.0 m resolution",
+    "datetime": "2014-01-01T00:00:00Z",
+    "start_datetime": "2014-01-01T00:00:00Z",
+    "end_datetime": "2017-12-31T23:59:59Z",
+    "providers": [
+      {
+        "name": "LiPAD",
+        "roles": [
+          "producer"
+        ]
+      }
+    ],
+    "gsd": 1.0,
+    "proj:epsg": 32651,
+    "matchgeo:method": "airborne_lidar",
+    "matchgeo:n_tiles": 286,
+    "matchgeo:labelled": false,
+    "matchgeo:has_annotations": false,
+    "proj:wkt2": "PROJCS[\"WGS 84 / UTM zone 51N\",GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",123],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH],AUTHORITY[\"EPSG\",\"32651\"]]"
+  },
+  "assets": {
+    "dem": {
+      "href": "data/PHL_TA/PHL_TA.tif",
+      "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+      "title": "Merged DEM \u2014 PHL_TA",
+      "roles": [
+        "data"
+      ],
+      "eo:bands": [
+        {
+          "name": "elevation",
+          "common_name": "elevation",
+          "unit": "meter"
+        }
+      ]
+    },
+    "tiles": {
+      "href": "data/PHL_TA/tiles/",
+      "type": "application/x-geotiff-tiles",
+      "title": "333\u00d7333 pixel tiles \u2014 PHL_TA",
+      "roles": [
+        "data"
+      ],
+      "x-asset-count": 286
+    },
+    "extent": {
+      "href": "data/PHL_TA/PHL_TA_extent.geojson",
+      "type": "application/geo+json",
+      "title": "Coverage extent polygon",
+      "roles": [
+        "metadata"
+      ]
+    },
+    "tile_index": {
+      "href": "data/PHL_TA/PHL_TA_tiles.geojson",
+      "type": "application/geo+json",
+      "title": "Tile index (grid)",
+      "roles": [
+        "metadata"
+      ]
+    }
+  },
+  "links": [
+    {
+      "rel": "self",
+      "href": "./PHL_TA.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "collection",
+      "href": "../collection.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "root",
+      "href": "../collection.json",
+      "type": "application/json"
+    }
+  ]
+}

stac/items/USA_GC.json

@@ -0,0 +1,120 @@
+{
+  "type": "Feature",
+  "stac_version": "1.0.0",
+  "id": "USA_GC",
+  "collection": "matchgeo-dem-v1",
+  "bbox": [
+    285921.5,
+    3970034.5,
+    289976.5,
+    3974030.0
+  ],
+  "geometry": {
+    "type": "Polygon",
+    "coordinates": [
+      [
+        [
+          289976.5,
+          3970034.5
+        ],
+        [
+          289976.5,
+          3974030.0
+        ],
+        [
+          285921.5,
+          3974030.0
+        ],
+        [
+          285921.5,
+          3970034.5
+        ],
+        [
+          289976.5,
+          3970034.5
+        ]
+      ]
+    ]
+  },
+  "properties": {
+    "title": "Grand Canyon, United States",
+    "description": "Grand Canyon, United States \u2014 lidar_ifsar at 10.0 m resolution",
+    "datetime": "2020-01-01T00:00:00Z",
+    "start_datetime": "2020-01-01T00:00:00Z",
+    "end_datetime": "2026-12-31T23:59:59Z",
+    "providers": [
+      {
+        "name": "USGS 3DEP",
+        "roles": [
+          "producer"
+        ]
+      }
+    ],
+    "gsd": 10.0,
+    "proj:epsg": 6341,
+    "matchgeo:method": "lidar_ifsar",
+    "matchgeo:n_tiles": 600,
+    "matchgeo:labelled": false,
+    "matchgeo:has_annotations": false,
+    "proj:wkt2": "COMPD_CS[\"NAD83(2011) / UTM zone 12N + NAVD88 height\",PROJCS[\"NAD83(2011) / UTM zone 12N\",GEOGCS[\"NAD83(2011)\",DATUM[\"NAD83_National_Spatial_Reference_System_2011\",SPHEROID[\"GRS 1980\",6378137,298.257222101,AUTHORITY[\"EPSG\",\"7019\"]],AUTHORITY[\"EPSG\",\"1116\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"6318\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",-111],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH],AUTHORITY[\"EPSG\",\"6341\"]],VERT_CS[\"NAVD88 height\",VERT_DATUM[\"North American Vertical Datum 1988\",2005,AUTHORITY[\"EPSG\",\"5103\"]],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Gravity-related height\",UP],AUTHORITY[\"EPSG\",\"5703\"]]]"
+  },
+  "assets": {
+    "dem": {
+      "href": "data/USA_GC/USA_GC.tif",
+      "type": "image/tiff; application=geotiff; profile=cloud-optimized",
+      "title": "Merged DEM \u2014 USA_GC",
+      "roles": [
+        "data"
+      ],
+      "eo:bands": [
+        {
+          "name": "elevation",
+          "common_name": "elevation",
+          "unit": "meter"
+        }
+      ]
+    },
+    "tiles": {
+      "href": "data/USA_GC/tiles/",
+      "type": "application/x-geotiff-tiles",
+      "title": "333\u00d7333 pixel tiles \u2014 USA_GC",
+      "roles": [
+        "data"
+      ],
+      "x-asset-count": 600
+    },
+    "extent": {
+      "href": "data/USA_GC/USA_GC_extent.geojson",
+      "type": "application/geo+json",
+      "title": "Coverage extent polygon",
+      "roles": [
+        "metadata"
+      ]
+    },
+    "tile_index": {
+      "href": "data/USA_GC/USA_GC_tiles.geojson",
+      "type": "application/geo+json",
+      "title": "Tile index (grid)",
+      "roles": [
+        "metadata"
+      ]
+    }
+  },
+  "links": [
+    {
+      "rel": "self",
+      "href": "./USA_GC.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "collection",
+      "href": "../collection.json",
+      "type": "application/json"
+    },
+    {
+      "rel": "root",
+      "href": "../collection.json",
+      "type": "application/json"
+    }
+  ]
+}