code/3dSAGER/data_partition.py

import json
import os
import config
from utils import *
import pickle as pkl
import argparse
from time import time
from multiprocessing import Pool, cpu_count
import numpy as np
from scipy.spatial import KDTree


class DataPartitionGenerator:
    def __init__(self, args, min_surfaces_num=10):
        self.dataset_name = args.dataset_name
        self.min_surfaces_num = min_surfaces_num
        self.train_neg_samples_list = args.train_neg_samples_list
        self.train_size_ratio_list = args.train_size_ratio_list
        self.test_size_ratio_list = args.test_size_ratio_list
        self.test_negative_samples_list = args.test_negative_samples_list
        self.cands_ids, self.index_ids = self._get_cands_and_index_ids()
        # self.create_dataset_partition_dict()

    def _get_cands_and_index_ids(self):
        dataset_config = json.load(open('dataset_configs.json'))[self.dataset_name]
        main_object_dict = getattr(self, f'_read_objects_{self.dataset_name}')(dataset_config)
        cands_ids = set(main_object_dict['cands'].keys())
        index_ids = set(main_object_dict['index'].keys())
        # Store centroids for grid split and spatial negative sampling
        self.cands_centroids = {k: np.asarray(main_object_dict['cands'][k]['centroid'], dtype=np.float64)
                                for k in main_object_dict['cands']}
        self.index_centroids = {k: np.asarray(main_object_dict['index'][k]['centroid'], dtype=np.float64)
                                for k in main_object_dict['index']}
        # Store pre-computed grid cells if available (from preprocess_hague.py cache)
        self.cands_grid_cells = {k: main_object_dict['cands'][k]['grid_cell']
                                 for k in main_object_dict['cands']
                                 if 'grid_cell' in main_object_dict['cands'][k]}
        self.index_grid_cells = {k: main_object_dict['index'][k]['grid_cell']
                                 for k in main_object_dict['index']
                                 if 'grid_cell' in main_object_dict['index'][k]}
        self.grid_meta = main_object_dict.get('grid_meta', {})
        del main_object_dict
        return cands_ids, index_ids

    # ------------------------------------------------------------------
    # Spatial grid helpers
    # ------------------------------------------------------------------

    @staticmethod
    def _assign_grid_cells(centroids_dict: dict, cell_size: float) -> dict:
        """
        Assign each building to a grid cell based on its 2D centroid.

        Parameters
        ----------
        centroids_dict : {id: np.ndarray([x, y, z])}
        cell_size : float  — cell side length in the same units as the CRS (meters)

        Returns
        -------
        {building_id: (cell_x, cell_y)}
        """
        if not centroids_dict:
            return {}
        coords = np.array([c[:2] for c in centroids_dict.values()])
        x_min, y_min = coords[:, 0].min(), coords[:, 1].min()
        cell_assignments = {}
        for bid, centroid in centroids_dict.items():
            cx = int(np.floor((centroid[0] - x_min) / cell_size))
            cy = int(np.floor((centroid[1] - y_min) / cell_size))
            cell_assignments[bid] = (cx, cy)
        return cell_assignments

    @staticmethod
    def _grid_split(cell_assignments: dict, train_ratio: float, seed: int,
                    contiguous_test: bool = True):
        """
        Assign grid cells to train or test and return per-building split.

        Each building belongs to exactly one cell (assigned by centroid).
        No building can appear in both splits.

        If contiguous_test=True (default): test cells are selected via BFS from the
        bottom-left corner of the grid, producing a single contiguous geographic block.
        This keeps the demo app's visible area coherent (train region) and ensures the
        test zone is a spatially distinct held-out area.

        If contiguous_test=False: cells are assigned randomly (original behaviour).

        Returns
        -------
        train_ids : set
        test_ids  : set
        """
        from collections import deque
        unique_cells = list(set(cell_assignments.values()))
        n_train_cells = max(1, int(round(train_ratio * len(unique_cells))))
        n_test_cells = len(unique_cells) - n_train_cells

        if contiguous_test and n_test_cells > 0:
            cell_set = set(map(tuple, unique_cells))
            # BFS starting from the bottom-left corner (min cx+cy) to grow a
            # contiguous test region
            start = min(cell_set, key=lambda c: (c[0] + c[1]))
            visited = {start}
            queue = deque([start])
            test_cells = []
            while queue and len(test_cells) < n_test_cells:
                cx, cy = queue.popleft()
                test_cells.append((cx, cy))
                for nc in [(cx + 1, cy), (cx - 1, cy), (cx, cy + 1), (cx, cy - 1)]:
                    if nc in cell_set and nc not in visited:
                        visited.add(nc)
                        queue.append(nc)
            test_cells = set(test_cells)
            train_cells = cell_set - test_cells
            strategy = "contiguous BFS"
        else:
            rng = np.random.default_rng(seed)
            rng.shuffle(unique_cells)
            train_cells = set(map(tuple, unique_cells[:n_train_cells]))
            test_cells  = set(map(tuple, unique_cells[n_train_cells:]))
            strategy = "random"

        train_ids = {bid for bid, cell in cell_assignments.items() if cell in train_cells}
        test_ids  = {bid for bid, cell in cell_assignments.items() if cell in test_cells}
        print(f"[GridSplit] {len(train_cells)} train cells / {len(test_cells)} test cells | "
              f"{len(train_ids)} train buildings / {len(test_ids)} test buildings "
              f"({strategy})")
        return train_ids, test_ids

    def _build_spatial_index(self, train_index_ids: set) -> None:
        """
        Build a KDTree on train-split index building centroids for
        neighborhood-aware negative sampling.
        """
        ids_list = [bid for bid in train_index_ids if bid in self.index_centroids]
        if not ids_list:
            self._index_kdtree = None
            self._index_ids_list = []
            return
        xy = np.array([self.index_centroids[bid][:2] for bid in ids_list], dtype=np.float64)
        self._index_kdtree = KDTree(xy)
        self._index_ids_list = ids_list

    # ------------------------------------------------------------------

    def create_dataset_partition_dict(self, seed):
        self.seed = seed
        cands_ids = self.cands_ids
        index_ids = self.index_ids

        # --- Spatial grid split ---
        cell_size = config.DataPartition.grid_cell_size
        train_ratio = config.DataPartition.train_ratio
        intersection_ids = cands_ids.intersection(index_ids)
        # Use pre-computed grid cells from the preprocessed cache when available
        # (real-world EPSG:7415 coordinates → correct spatial splits)
        if self.cands_grid_cells:
            intersection_cell_assignments = {bid: self.cands_grid_cells[bid]
                                             for bid in intersection_ids
                                             if bid in self.cands_grid_cells}
            print(f"[GridSplit] Using pre-computed grid cells "
                  f"(cell_size={self.grid_meta.get('cell_size', cell_size):.0f} m, "
                  f"{len(intersection_cell_assignments)} buildings)")
        else:
            intersection_centroids = {bid: self.index_centroids[bid]
                                      for bid in intersection_ids if bid in self.index_centroids}
            intersection_cell_assignments = self._assign_grid_cells(intersection_centroids, cell_size)
        train_intersection_ids, test_intersection_ids = self._grid_split(
            intersection_cell_assignments, train_ratio, seed,
            contiguous_test=config.DataPartition.contiguous_test
        )
        # Build KDTree on train-split index buildings for neighborhood negative sampling
        self._build_spatial_index(train_intersection_ids)

        train_negative_sampling_dict = self._get_train_negative_sampling_dict(
            train_intersection_ids, index_ids
        )
        test_dict = self._get_test_ids_dict(
            test_intersection_ids, index_ids, train_negative_sampling_dict
        )
        dataset_partition_dict = {'train': {'negative_sampling': train_negative_sampling_dict}, 'test': test_dict}
        self._save_dataset_partition_dict(dataset_partition_dict)

    def _get_train_negative_sampling_dict(self, cands_ids, index_ids):
        np.random.seed(self.seed)
        train_ids_dict = {}
        intersection_set = cands_ids.intersection(index_ids)
        for train_size, ratio_val in self.train_size_ratio_list.items():
            print(f"Creating training data ({train_size})")
            train_ids_dict[train_size] = {}
            train_ids_size_num = int(ratio_val * len(intersection_set))
            train_ids_for_curr_size = set(np.random.choice(list(intersection_set), train_ids_size_num, replace=False))
            for neg_samples_num in self.train_neg_samples_list:
                train_ids_dict[train_size][neg_samples_num] = self._get_pairs_per_neg_samples(train_ids_for_curr_size,
                                                                                              index_ids,
                                                                                              neg_samples_num)
        return train_ids_dict

    def _generate_pairs_for_id(self, args):
        """
        Generate one positive pair + neg_samples_num negative pairs for cand_id.

        Negative sampling strategy (config.Blocking.neighborhood_neg_ratio):
          - Up to `neighborhood_neg_ratio` fraction drawn from buildings within
            `neighborhood_radius` meters (same neighborhood, hard negatives).
          - Remainder filled randomly from the full index pool.
        Falls back to fully random sampling if the KDTree is unavailable.
        """
        cand_id, index_ids_list, neg_samples_num, seed = args
        rng = np.random.default_rng(seed + hash(cand_id) % 1_000_000)

        neighborhood_radius = config.Blocking.neighborhood_radius
        neighborhood_neg_ratio = config.Blocking.neighborhood_neg_ratio
        n_neighborhood = int(round(neg_samples_num * neighborhood_neg_ratio))
        n_random = neg_samples_num - n_neighborhood

        spatial_neg_ids = []
        # Spatial candidates from KDTree
        if (n_neighborhood > 0
                and self._index_kdtree is not None
                and cand_id in self.cands_centroids):
            cand_xy = self.cands_centroids[cand_id][:2]
            neighbor_rows = self._index_kdtree.query_ball_point(cand_xy, r=neighborhood_radius)
            neighbor_ids = [self._index_ids_list[i] for i in neighbor_rows
                            if self._index_ids_list[i] != cand_id]
            if len(neighbor_ids) >= n_neighborhood:
                chosen = rng.choice(neighbor_ids, n_neighborhood, replace=False)
                spatial_neg_ids = list(chosen)
            else:
                spatial_neg_ids = neighbor_ids          # take all available
                n_random = neg_samples_num - len(spatial_neg_ids)

        # Random candidates to fill the remainder
        exclude = set(spatial_neg_ids) | {cand_id}
        remaining = [bid for bid in index_ids_list if bid not in exclude]
        if n_random > 0 and remaining:
            n_draw = min(n_random, len(remaining))
            random_neg_ids = list(rng.choice(remaining, n_draw, replace=False))
        else:
            random_neg_ids = []

        all_neg_ids = spatial_neg_ids + random_neg_ids
        neg_pairs = [(cand_id, neg_id) for neg_id in all_neg_ids]
        return [(cand_id, cand_id)] + neg_pairs

    # def _get_pairs_per_neg_samples(self, ids_for_curr_size, index_ids, neg_samples_num):
    #     np.random.seed(self.seed)
    #     pos_pairs = [(cand_id, cand_id) for cand_id in ids_for_curr_size]
    #     neg_pairs = []
    #     for cand_id in ids_for_curr_size:
    #         neg_samples = set(np.random.choice(list(index_ids), neg_samples_num, replace=False))
    #         neg_pairs.extend([(cand_id, neg_sample) for neg_sample in neg_samples if neg_sample != cand_id])
    #     all_pairs = pos_pairs + neg_pairs
    #     np.random.shuffle(all_pairs)
    #     return all_pairs

    def _init_seed(self):
        np.random.seed(self.seed)

    def _get_pairs_per_neg_samples(self, ids_for_curr_size, index_ids, neg_samples_num):
        ids_for_curr_size_list = list(ids_for_curr_size)
        index_ids_list = list(index_ids)
        args = [
            (cand_id, index_ids_list, neg_samples_num, self.seed)
            for cand_id in ids_for_curr_size_list
        ]
        with Pool(cpu_count(), initializer=self._init_seed, initargs=()) as pool:
            results = pool.map(self._generate_pairs_for_id, args)
        all_pairs = [pair for sublist in results for pair in sublist]
        np.random.seed(self.seed)
        np.random.shuffle(all_pairs)
        return all_pairs

    def _get_test_ids_dict(self, cands_ids, index_ids, train_ids_dict):
        test_ids_dict = {}
        intersection_set = cands_ids.intersection(index_ids)
        test_ids_dict['matching'] = self._get_test_pairs_for_matching(index_ids, intersection_set, train_ids_dict)
        test_ids_dict['blocking'] = self._get_test_data_for_blocking(cands_ids, index_ids,
                                                                     intersection_set,
                                                                     train_ids_dict)
        return test_ids_dict

    def _get_test_pairs_for_matching(self, index_ids, intersection_set, train_ids_dict):
        print("Creating test data for matching")
        test_matching_dict = {}
        test_matching_dict['negative_sampling'] = self._get_negative_sampling_test_ids_dict(index_ids,
                                                                                            intersection_set,
                                                                                            train_ids_dict)
        return test_matching_dict

    def _get_negative_sampling_test_ids_dict(self, index_ids, intersection_set, train_ids_dict):
        np.random.seed(self.seed)
        local_test_ids_dict = {}
        for test_size, ratio_val in self.test_size_ratio_list.items():
            print(f"Creating test data for matching ({test_size})")
            local_test_ids_dict[test_size] = {}
            corresponding_train_cands_ids = set \
                ([pair[0] for pair in train_ids_dict[test_size][self.train_neg_samples_list[0]]])
            potential_test_ids = intersection_set - corresponding_train_cands_ids
            test_ids_size_num = int(ratio_val * len(potential_test_ids))
            test_ids_for_curr_size = set(np.random.choice(list(potential_test_ids), test_ids_size_num, replace=False))
            for test_neg_samples in self.test_negative_samples_list:
                local_test_ids_dict[test_size][test_neg_samples] = self._get_pairs_per_neg_samples \
                    (test_ids_for_curr_size, index_ids, test_neg_samples)
        return local_test_ids_dict

    def _get_test_data_for_blocking(self, cands_ids, index_ids, intersection_set, train_ids_dict, non_matched_rat=0.2):
        test_blocking_dict = defaultdict(dict)
        for test_size, ratio_val in self.test_size_ratio_list.items():
            print(f"Creating test data for blocking ({test_size})")
            corresponding_train_cands_ids = set([pair[0] for pair in
                                                 train_ids_dict[test_size][self.train_neg_samples_list[0]]])
            potential_cands_test_ids = intersection_set - corresponding_train_cands_ids
            # non_matched_cands_ids = cands_ids - intersection_set
            cands_test_ids = set(np.random.choice(list(potential_cands_test_ids),
                                                  int(ratio_val * len(potential_cands_test_ids)), replace=False))
            # select non-matched_ratio of the intersection_set and remove them from index_ids
            index_ids_to_remove = set(np.random.choice(list(cands_test_ids),
                                                       int(non_matched_rat * len(cands_test_ids)), replace=False))
            # non_matched_cands_ids = set(np.random.choice(list(non_matched_cands_ids),
            #                                 int(non_matched_rat * len(non_matched_cands_ids)), replace=False))
            # index_test_ids = cands_test_ids.copy()
            # cands_test_ids.update(non_matched_cands_ids)
            # remove from index_ids the ids that are in index_ids_to_remove
            index_test_ids = index_ids - index_ids_to_remove
            index_test_ids = set(np.random.choice(list(index_test_ids),
                                                   int(ratio_val * len(index_test_ids)), replace=False))
            # index_test_ids.update(set(np.random.choice(list(index_ids),
            #                                            int(ratio_val * len(index_ids)),
            #                                            replace=False)))
            test_blocking_dict[test_size] = {'cands': cands_test_ids, 'index': index_test_ids}
        return test_blocking_dict

    def _read_objects_bo_em(self, dataset_config):
        objects_path_dict = read_object_path_dict(dataset_config)
        object_dict = defaultdict(dict)
        for objects_type, objects_path in objects_path_dict.items():
            for filename in os.listdir(objects_path):
                file_ind = int(filename.split('.')[0])
                json_data = read_json(objects_path, file_ind)
                object_dict = self._insert_polygon_mesh(object_dict, objects_type, json_data, file_ind)
            object_dict[objects_type] = dict(sorted(object_dict[objects_type].items()))
        return object_dict

    @staticmethod
    def _remove_train_objects_from_object_dict(object_dict, train_ids):
        for objects_type in object_dict.keys():
            object_dict[objects_type] = {
                object_id: object_data
                for object_id, object_data in object_dict[objects_type].items()
                if object_id not in train_ids
            }
        return object_dict

    def _read_objects_gpkg(self, dataset_config):
        objects_path_dict = read_object_path_dict(dataset_config)
        object_dict = defaultdict(dict)
        for objects_type, objects_path in objects_path_dict.items():
            for filename in os.listdir(objects_path):
                file_ind = int(filename.split('.')[0])
                json_data = read_json(objects_path, file_ind)
                json_data = json.loads(json_data)
                object_dict = self._insert_polygon_mesh(object_dict, objects_type, json_data, file_ind)
            object_dict[objects_type] = dict(sorted(object_dict[objects_type].items()))
        return object_dict

    def _read_objects_delivery3(self, dataset_config):
        objects_path_dict = read_object_path_dict(dataset_config)
        object_dict = defaultdict(dict)
        mapping_dict = defaultdict(dict)
        inv_mapping_dict = defaultdict(dict)
        for objects_type, objects_path in objects_path_dict.items():
            for file_ind, file_name in enumerate(os.listdir(objects_path)):
                file_name = file_name.split('.')[0]
                json_data = read_json(objects_path, file_name)
                object_dict = self._insert_polygon_mesh(object_dict, objects_type, json_data, file_ind)
                mapping_dict[objects_type][file_ind] = file_name
                inv_mapping_dict[objects_type][file_name] = file_ind
            object_dict[objects_type] = dict(sorted(object_dict[objects_type].items()))
        object_dict['mapping_dict'] = mapping_dict
        object_dict['inv_mapping_dict'] = inv_mapping_dict
        return object_dict

    @staticmethod
    def _process_cityjson_file(args):
        file_path, objects_type, standardize_obj_key_fn, get_polygon_mesh_fn = args
        local_object_dict = {}
        try:
            with open(file_path, 'r') as f:
                data = json.load(f)
            vertices = data['vertices']
            for obj_key in data['CityObjects']:
                try:
                    new_obj_key = standardize_obj_key_fn(obj_key, objects_type)
                    polygon_mesh_data = get_polygon_mesh_fn(data, obj_key, vertices)
                    if polygon_mesh_data is not None:
                        local_object_dict[new_obj_key] = polygon_mesh_data
                except:
                    continue
        except:
            pass
        return objects_type, local_object_dict

    def _read_objects_Hague(self, dataset_config):
        """Load from preprocessed cache (produced by preprocess_hague.py).

        The cache contains real-world EPSG:7415 coordinates and pre-computed
        grid_cell assignments, so grid splits are spatially correct.
        Run `python preprocess_hague.py` once before calling this.
        """
        raw_cache_path = (f"{config.FilePaths.object_dict_path}"
                          f"{self.dataset_name}_raw.joblib")
        if not os.path.exists(raw_cache_path):
            raise FileNotFoundError(
                f"Preprocessed cache not found: {raw_cache_path}\n"
                f"Run:  python preprocess_hague.py"
            )
        print(f"Loading preprocessed cache: {raw_cache_path}")
        return joblib.load(raw_cache_path)

    def _read_objects_Lyon_CT(self, dataset_config):
        """Load Lyon cross-time dataset from preprocessed cache."""
        raw_cache_path = (f"{config.FilePaths.object_dict_path}"
                          f"{self.dataset_name}_raw.joblib")
        if not os.path.exists(raw_cache_path):
            raise FileNotFoundError(
                f"Lyon cross-time cache not found: {raw_cache_path}")
        print(f"Loading Lyon_CT preprocessed cache: {raw_cache_path}")
        return joblib.load(raw_cache_path)

    def _read_objects_Lyon_CT_09_15(self, dataset_config):
        """Load Lyon 2009→2015 cross-time dataset (6-year gap)."""
        raw_cache_path = (f"{config.FilePaths.object_dict_path}"
                          f"{self.dataset_name}_raw.joblib")
        if not os.path.exists(raw_cache_path):
            raise FileNotFoundError(
                f"Lyon CT 09→15 cache not found: {raw_cache_path}")
        print(f"Loading Lyon_CT_09_15 cache: {raw_cache_path}")
        return joblib.load(raw_cache_path)

    def _read_objects_Lyon_CT_Full(self, dataset_config):
        """Load Lyon 2009→2012 cross-time dataset (all confidence tiers)."""
        raw_cache_path = (f"{config.FilePaths.object_dict_path}"
                          f"{self.dataset_name}_raw.joblib")
        if not os.path.exists(raw_cache_path):
            raise FileNotFoundError(f"Lyon CT Full cache not found: {raw_cache_path}")
        print(f"Loading Lyon_CT_Full cache: {raw_cache_path}")
        return joblib.load(raw_cache_path)

    def _read_objects_Lyon_CT_12_15(self, dataset_config):
        """Load Lyon 2012→2015 cross-time dataset (3-year gap, CityGML 1.0→2.0)."""
        raw_cache_path = (f"{config.FilePaths.object_dict_path}"
                          f"{self.dataset_name}_raw.joblib")
        if not os.path.exists(raw_cache_path):
            raise FileNotFoundError(
                f"Lyon CT 12→15 cache not found: {raw_cache_path}")
        print(f"Loading Lyon_CT_12_15 cache: {raw_cache_path}")
        return joblib.load(raw_cache_path)

    @staticmethod
    def _generate_object_dict(results):
        object_dict = defaultdict(dict)
        for objects_type, obj_dict in results:
            object_dict[objects_type].update(obj_dict)
        intersection_keys = set(object_dict['cands'].keys()).intersection(object_dict['index'].keys())
        object_dict['cands'] = {k: object_dict['cands'][k] for k in intersection_keys}
        return object_dict, intersection_keys


    @staticmethod
    def _print_object_dict_info(object_dict, intersection_keys):
        print(f"Number of overlapping objects: {len(intersection_keys)}")
        print(f"Number of cands: {len(object_dict['cands'])}")
        print(f"Number of index: {len(object_dict['index'])}")
        return

    @staticmethod
    def _update_object_dict_mapping(object_dict, objects_path_dict):
        for objects_type in objects_path_dict:
            keys = list(object_dict[objects_type].keys())
            object_dict['mapping_dict'][objects_type] = {i: k for i, k in enumerate(keys)}
            object_dict['inv_mapping_dict'][objects_type] = {k: i for i, k in enumerate(keys)}
        return object_dict


    # def _read_objects_Hague(self, dataset_config):
    #     objects_path_dict = read_object_path_dict(dataset_config)
    #     object_dict = defaultdict(dict)
    #     for objects_type, objects_path in objects_path_dict.items():
    #         print(f"Reading {objects_type} objects")
    #         file_list = [f for f in os.listdir(objects_path) if f.endswith('.json')]
    #         for file_ind, file_name in enumerate(file_list):
    #             print(f"File number {file_ind + 1} out of {len(file_list)}")
    #             file_path = ''.join([objects_path, file_name])
    #             with open(file_path, 'r') as f:
    #                 data = json.load(f)
    #             vertices = data['vertices']
    #             for obj_key in data['CityObjects'].keys():
    #                 try:
    #                     new_obj_key = self.standardize_obj_key(obj_key, objects_type)
    #                     polygon_mesh_data = self._get_polygon_mesh(data, obj_key, vertices)
    #                     if polygon_mesh_data is not None:
    #                         object_dict[objects_type][new_obj_key] = polygon_mesh_data
    #                 except:
    #                     continue
    #     intersection_keys = set(object_dict['cands'].keys()).intersection(set(object_dict['index'].keys()))
    #     object_dict['cands'] = {obj_key: object_dict['cands'][obj_key] for obj_key in intersection_keys}
    #     print(f"Number of overlapping objects: {len(intersection_keys)}")
    #     print(f"Number of cands: {len(object_dict['cands'])}")
    #     print(f"Number of index: {len(object_dict['index'])}")
    #     for objects_type in objects_path_dict.keys():
    #         object_dict['mapping_dict'][objects_type] = {ind: obj_key for ind, obj_key in
    #                                                      enumerate(object_dict[objects_type].keys())}
    #         object_dict['inv_mapping_dict'][objects_type] = {obj_key: ind for ind, obj_key in
    #                                                          enumerate(object_dict[objects_type].keys())}
    #     return object_dict

    @staticmethod
    def standardize_obj_key(obj_key, object_type):
        if object_type == 'cands':
            return obj_key.split('bag_')[1]
        elif object_type == 'index':
            return obj_key.split('NL.IMBAG.Pand.')[1].split('-0')[0]
        else:
            raise ValueError('Invalid source')

    def _insert_polygon_mesh(self, object_dict, obj_type, obj_data, obj_ind=None):
        vertices = obj_data['vertices']
        obj_key = list(obj_data['CityObjects'].keys())[0]
        polygon_mesh = self._get_polygon_mesh(obj_data, obj_key, vertices)
        if polygon_mesh is not None:
            object_dict[obj_type][obj_ind] = polygon_mesh
        return object_dict

    def _get_polygon_mesh(self, obj_data, obj_key, vertices):
        boundaries = obj_data['CityObjects'][obj_key]['geometry'][0]['boundaries'][0]
        if len(boundaries) < self.min_surfaces_num:
            return None
        polygon_mesh = []
        for surface in boundaries:
            polygon_mesh.append([vertices[i] for sub_surface_list in surface for i in sub_surface_list])
        vertices = self._get_vertices(polygon_mesh)
        centroid = self._compute_object_centroid(vertices)
        return {'polygon_mesh': polygon_mesh, 'vertices': vertices, 'centroid': centroid}

    @staticmethod
    def _compute_object_centroid(vertices):
        unique_vertices = np.array(vertices)
        return unique_vertices.mean(axis=0)

    @staticmethod
    def _get_vertices(polygon_mesh):
        return np.unique(np.array([coord for surface in polygon_mesh for coord in surface]), axis=0)

    def _save_dataset_partition_dict(self, dataset_partition_dict):
        if not os.path.exists(config.FilePaths.dataset_partition_path):
            os.makedirs(config.FilePaths.dataset_partition_path)
        path = f"{config.FilePaths.dataset_partition_path}{self.dataset_name}_seed{self.seed}.pkl"
        pkl.dump(dataset_partition_dict, open(path, 'wb'))
        print(f"Saved the dataset partition dict to {path}")
        return


def generate_partition_dicts(args):
    partition_dict_obj = DataPartitionGenerator(args)
    for seed in range(1, args.seeds_num + 1):
        print(f"Creating dataset partition dict for seed {seed}")
        start_time = time()
        partition_dict_obj.create_dataset_partition_dict(seed)
        end_time = time()
        print(f"Elapsed time for seed {seed}: {end_time - start_time}")
        print(3 * '--------------------------')
    print("Done!")


def get_potnetial_neg_pairs(dataset_size_version, bkafi_dim, train_or_test, seed):
    file_name = get_file_name()
    file_name.replace('concatenation', 'division')
    # if train_or_test == 'train':
    #     file_name = file_name.replace('Operator', 'Train_Operator')
    blocking_results_dir = config.FilePaths.results_path + 'blocking_output/'
    blocking_results_path = (f"{blocking_results_dir}{file_name}_"
                             f"{dataset_size_version}_neg_samples_num2_vector_normalization_True_sdr_factor_False_"
                             f"bkafi_criterion=feature_importance_seed={seed}.joblib")
    print(f"\nLoading blocking results from {blocking_results_path}")
    blocking_dict = joblib.load(blocking_results_path)
    print(f"Loaded blocking results from {blocking_results_path}")
    neg_pairs = blocking_dict['neg_pairs'][bkafi_dim]
    return neg_pairs


def process_blocking_based_pairs(seed, neg_samples_num, cands_with_match_ids, potential_neg_pairs):
    np.random.seed(seed)
    pos_pairs = [(cand_id, cand_id) for cand_id in cands_with_match_ids]
    neg_pairs = potential_neg_pairs[neg_samples_num + 1]
    all_pairs = pos_pairs + neg_pairs
    np.random.shuffle(all_pairs)
    return all_pairs


def get_blocking_based_pairs(args, seed, train_or_test, dataset_partition_dict):
    local_test_ids_dict = {}
    neg_samples_list = args.train_neg_samples_list if train_or_test == 'train' else args.test_negative_samples_list
    # Only inject pairs for the dataset_size we actually ran blocking for.
    # If dataset_size_version is not set on args, fall back to all sizes.
    sizes_to_process = (
        [args.dataset_size_version]
        if hasattr(args, 'dataset_size_version') and args.dataset_size_version
        else ['small', 'medium', 'large']
    )
    for set_size in sizes_to_process:
        local_test_ids_dict[set_size] = {}
        if train_or_test == 'train':
            negative_sampling_pair_set = dataset_partition_dict['train']['negative_sampling'][set_size][2]
        else:
            negative_sampling_pair_set = dataset_partition_dict['test']['matching']['negative_sampling'][set_size][2]
        cands_with_match_ids = set([pair[0] for pair in negative_sampling_pair_set if pair[0] == pair[1]])
        potential_neg_pairs = get_potnetial_neg_pairs(set_size, args.bkafi_dim, train_or_test, seed)
        for neg_samples_num in neg_samples_list:
            local_test_ids_dict[set_size][neg_samples_num] = process_blocking_based_pairs(seed, neg_samples_num,
                                                                                          cands_with_match_ids,
                                                                                          potential_neg_pairs)
    return local_test_ids_dict


def add_blocking_based_mode_pairs(args):
    for seed in range(1, args.seeds_num + 1):
        # read the existing dataset partition dict

        dataset_partition_dict = pkl.load(open(f"data/dataset_partitions/{args.dataset_name}_seed{seed}.pkl", 'rb'))
        print(f"Loaded dataset partition dict for seed {seed} with blocking-based pairs")
        dataset_partition_dict['train']['blocking-based'] = get_blocking_based_pairs(args, seed, 'train',
                                                                                     dataset_partition_dict)
        dataset_partition_dict['test']['matching']['blocking-based'] = get_blocking_based_pairs(args, seed, 'test',
                                                                                                dataset_partition_dict)
        # save the updated dataset partition dict
        pkl.dump(dataset_partition_dict, open(f"data/dataset_partitions/{args.dataset_name}_seed{seed}.pkl", 'wb'))
        print(f"Updated dataset partition dict for seed {seed} with blocking-based pairs")
        print(3 * '--------------------------')
    return


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument('--dataset_name', type=str, default=config.Constants.dataset_name)
    parser.add_argument('--blocking_based_mode', type=bool, default=True)
    parser.add_argument('--seeds_num', type=int, default=config.Constants.seeds_num)
    parser.add_argument('--train_neg_samples_list', type=list, default=[2, 5])
    parser.add_argument('--test_negative_samples_list', type=list, default=[2, 5])
    parser.add_argument('--train_size_ratio_list', type=dict, default={"small": 0.1, "medium": 0.4, "large": 0.6})
    parser.add_argument('--test_size_ratio_list', type=dict, default={"small": 0.1, "medium": 0.5, "large": 1.0})
    parser.add_argument('--bkafi_dim', type=int, default=3)

    args = parser.parse_args()

    if args.blocking_based_mode:  # load existing partitions and add blocking-based partitions for the matching mode
        add_blocking_based_mode_pairs(args)
    else:
        generate_partition_dicts(args)