preprocess/ssg/ssg_main.py

import json
import pickle
from tqdm import tqdm
from pathlib import Path
from omegaconf import OmegaConf

import torch
import networkx as nx
import numpy as np

import ssg_utils as utils
from ssg_data import dictionary
from ssg_data.ssg_visualize import vis_dataset
from ssg_data.script.ObjNode import ObjNode
from relationships.support import cal_support_relations
from relationships.proximity import cal_proximity_relationships
from relationships.hanging import cal_hanging_relationships
from relationships.multi_objs import find_aligned_furniture, find_middle_furniture


def default_dump(obj):
    """Convert numpy classes to JSON serializable objects."""
    if isinstance(obj, (np.integer, np.floating, np.bool_)):
        return obj.item()
    elif isinstance(obj, np.ndarray):
        return obj.tolist()
    else:
        return obj

def convert_pc_to_box(obj_pc):
    xmin = np.min(obj_pc[:,0])
    ymin = np.min(obj_pc[:,1])
    zmin = np.min(obj_pc[:,2])
    xmax = np.max(obj_pc[:,0])
    ymax = np.max(obj_pc[:,1])
    zmax = np.max(obj_pc[:,2])
    center = [(xmin+xmax)/2, (ymin+ymax)/2, (zmin+zmax)/2]
    box_size = [xmax-xmin, ymax-ymin, zmax-zmin]
    return center, box_size

def init_camera_view():
    camera_view = [0, -1, 0]
    camera_pos = [0, 0, 0]
    camera_view = camera_view / np.linalg.norm(camera_view)

    if camera_view[0] < 0:
        camera_angle = -utils.get_theta(camera_view, [0, 1, 0])
    else:
        camera_angle = utils.get_theta(camera_view, [0, 1, 0])

    return camera_view, camera_pos, camera_angle

def filter_bad_label(input_label):
    bad_label_list = ['ceiling', 'wall', 'door', 'doorframe', 'object']
    for o in bad_label_list:
        if o in input_label:
            return False

    return True

def get_obj_room_id (org_id):
    infos = org_id.split('|')
    if infos[1] == 'surface':
        return int(infos[2])
    else:
        return int(infos[1])

def generate_object_info(save_root, scene_name) :
    object_json_list = []

    inst2label_path = save_root / 'instance_id_to_label'
    pcd_path = save_root / 'pcd_with_global_alignment'

    inst_to_label = torch.load(inst2label_path / f"{scene_name}.pth")
    pcd_data = torch.load(pcd_path / f'{scene_name}.pth')

    points, colors, instance_labels = pcd_data[0], pcd_data[1], pcd_data[-1]
    pcds = np.concatenate([points, colors], 1)

    x_max, y_max, z_max = points.max(axis=0)
    x_min, y_min, z_min = points.min(axis=0)

    obj_pcds = []
    for i in np.unique(instance_labels):
        if i < 0:
            continue
        mask = instance_labels == i     # time consuming
        obj_pcds.append((pcds[mask], inst_to_label[int(i)], i))

    for _, (obj, obj_label, i) in enumerate(obj_pcds):
        gt_center, gt_size = convert_pc_to_box(obj)
        object_json = {
            'id': int(i),
            'label': obj_label,
            'position': gt_center,
            'size': gt_size,
            'mesh': None
        }
        object_json_list.append(object_json)

    # add scan_id
    object_json_string = {
        'scan': scene_name,
        'point_max': [x_max, y_max, z_max],
        'point_min': [x_min, y_min, z_min],
        'object_json_string': object_json_list,
        'inst_to_label': inst_to_label,
    }

    return object_json_string

def generate_ssg_data(dataset, scene_path, pre_load_path):
    ssg_data = {}
    pre_load_file_save_path = pre_load_path / (dataset + '.pkl')
    if pre_load_file_save_path.exists():
        print('Using preprocessed scene data')
        with open(pre_load_file_save_path, 'rb') as f:
            ssg_data = pickle.load(f)
    else:
        print('Preprocessing scene data')
        scans = [s.stem for s in (scene_path / 'pcd_with_global_alignment').glob('*.pth')]
        scans.sort()
        for scan_id in tqdm(scans):
            object_json_string = generate_object_info(scene_path, scan_id)
            if object_json_string is not None:
                ssg_data[scan_id] = object_json_string
        with open(pre_load_file_save_path, 'wb') as f:
            pickle.dump(ssg_data, f)

    return ssg_data

def main(cfg):
    cfg.rels_save_path.mkdir(parents=True, exist_ok=True)
    ssg_data = generate_ssg_data(cfg.dataset, cfg.scene_path, cfg.rels_save_path)
    scans_all = list(ssg_data.keys())

    ### init camera ###
    camera_view, camera_pos, camera_angle = init_camera_view()
    for scan_id in scans_all:
        objects_save = {}
        relationship_save = {}
        inst_dict = {}

        print('Processing ', scan_id)

        objects_info = ssg_data[scan_id]['object_json_string']
        inst_labels = ssg_data[scan_id]['inst_to_label']
        # bad case
        if len(objects_info) == 0:
            continue

        # construct object graph
        G = nx.DiGraph()
        # create nodes
        ObjNode_dict = {}

        # log objects of the same category
        for inst in inst_labels:
            if inst_labels[inst] not in inst_dict:
                inst_dict[inst_labels[inst]] = 1
            else:
                inst_dict[inst_labels[inst]] += 1

        x_max, y_max, z_max = ssg_data[scan_id]['point_max']
        x_min, y_min, z_min = ssg_data[scan_id]['point_min']
        scene_center = np.array([(x_max + x_min) / 2, (y_max + y_min) / 2, (z_max + z_min) / 2])
        # floor bad
        if z_max == z_min:
            z_max = z_min + 5
        scene_high = z_max - z_min

        # generate object node for graph
        obj_z_min = 1000
        floor_idx = -100
        for obj in objects_info:
            if np.array(obj['size']).sum() == 0:
                continue
            if not filter_bad_label(obj['label']):
                continue
            if obj['label'] == 'floor':
                floor_idx = int(obj['id'])
            node = ObjNode(id=int(obj['id']),
                           position=obj['position']-scene_center,
                           label=obj['label'],
                           mesh=obj['mesh'] if 'mesh' in obj else None,
                           size=np.array(obj['size']),
                           children=obj['children'] if 'children' in obj else None,
                           room_id=get_obj_room_id (obj['id_org']) if 'id_org' in obj else None,
                           dataset=cfg.dataset)

            if obj['position'][2] - obj['size'][2]/2 < obj_z_min:
                obj_z_min = obj['position'][2]-obj['size'][2]/2

            obj['count'] = inst_dict[node.label]
            obj['caption'] = ''

            ObjNode_dict[int(obj['id'])] = node
            G.add_node(node.id, label=node.label)

        # added special nodes (wall camera)
        G.add_node(-1, label='CAMERA')
        G.add_node(-2, label='wall')

        # special node for floor
        if floor_idx == -100:
            G.add_node(-3, label='floor')
            fx, fy, fz = scene_center[0], scene_center[1], obj_z_min
            node = ObjNode(id=-3,
                           position=np.array([fx, fy, fz]) - scene_center,
                           label='floor',
                           size=[(x_max-x_min)*1.2, (y_max-y_min)*1.2, (z_max-z_min)*0.1],
                           dataset=cfg.dataset)
            ObjNode_dict[-3] = node
            floor_idx = -3
        else:
            fx, fy, fz = scene_center[0], scene_center[1], obj_z_min
            node_ = ObjNode_dict[floor_idx]
            if node_.size[2] > 0:
                node = ObjNode(id=floor_idx,
                               position= np.array([fx, fy, fz]) - scene_center,
                               label='floor',
                               size=[max((x_max-x_min)*1.2, node_.size[0]),
                                     max((y_max-y_min)*1.2, node_.size[0]),
                                     node_.size[2]],
                               dataset=cfg.dataset)
            else:
                node = ObjNode(id=floor_idx,
                               position= np.array([fx, fy, fz]) - scene_center,
                               label='floor',
                               size=[max((x_max-x_min)*1.2, node_.size[0]),
                                     max((y_max-y_min)*1.2, node_.size[0]),
                                     (z_max-z_min)*0.1],
                               dataset=cfg.dataset)

            ObjNode_dict[floor_idx] = node

        # support embedded relationship
        if cfg.dataset.lower() in ['procthor']:
            support_relations = []
            embedded_relations = []
            hanging_objs_dict = {}
            for src_id, _ in ObjNode_dict.items():
                src_obj = ObjNode_dict[src_id]
                if src_obj.z_min <= ObjNode_dict[floor_idx].z_max and src_obj.id != floor_idx:
                    support_relations.append(utils.generate_relation(floor_idx, src_id,'support'))
                    hanging_objs_dict[src_id] = 1

                if src_obj.children != []:
                    for child in src_obj.children:
                        hanging_objs_dict[child] = 1
                        if child not in ObjNode_dict:
                            continue
                        if ObjNode_dict[child].z_max < src_obj.z_max:
                            embedded_relations.append(utils.generate_relation(src_id, child ,'inside_express'))
                        else:
                            support_relations.append(utils.generate_relation(src_id, child , 'support'))

        else:
            support_relations, embedded_relations, hanging_objs_dict = cal_support_relations(ObjNode_dict, camera_angle)
        for rela in support_relations:
            target_obj_id, obj_id, _ = rela
            G.add_edge(target_obj_id, obj_id, label='support') # optimizer

        # hanging relationships
        hanging_relationships = cal_hanging_relationships(ObjNode_dict, hanging_objs_dict, camera_angle,
                                                          scene_high, dataset=cfg.dataset)

        # iterate graph to cal saptial relationships
        proximity_relations = []
        for node in G:
            neighbor = dict(nx.bfs_successors(G, source=node, depth_limit=1))
            if len(neighbor[node]) > 1:
                neighbor_objs = neighbor[node]
                proximity = cal_proximity_relationships(neighbor_objs, camera_angle, ObjNode_dict, scene_high)
                proximity_relations += proximity

        # added some special relations and oppo support relationships
        oppo_support_relations = []
        objects_rels = support_relations + embedded_relations + hanging_relationships
        for idx, rels in enumerate(objects_rels):
            src, tgt, rela = rels
            if rela == 'support':
                oppo_support_relations.append(utils.generate_relation(src, tgt, 'oppo_support'))

            if src == -2 or tgt == -2:
                continue
            src_label = ObjNode_dict[src].label
            tgt_label = ObjNode_dict[tgt].label

            if src_label in dictionary.added_hanging and dictionary.added_hanging[src_label] == tgt_label:
                objects_rels[idx][2] = 'hanging'
            if tgt_label in dictionary.added_hanging and dictionary.added_hanging[tgt_label] == src_label:
                objects_rels[idx][2] = 'hanging'

        # multi objects
        multi_objs_relationships = []

        # added aligned relationship
        furniture_list = list(ObjNode_dict.keys())
        aligned_furniture = find_aligned_furniture(furniture_list, ObjNode_dict, 0.065)

        for _, aligned_furni in enumerate(aligned_furniture):
            multi_objs_relationships.append([aligned_furni, 'Aligned'])

        # added in the middle of relationship
        middle_relationships = find_middle_furniture(proximity_relations, ObjNode_dict)

        # output json
        relationships_json_string = {
            'scan': scan_id,
            'camera_view': camera_view,
            'camera_position': camera_pos,
            'relationships': objects_rels + proximity_relations + oppo_support_relations,
            'multi_objs_relationships': multi_objs_relationships + middle_relationships,
        }

        np.random.shuffle(objects_rels)
        # visualize scene
        if cfg.visualize:
            vis_dataset(ObjNode_dict=ObjNode_dict,
                        relation=proximity_relations,
                        scene_path=cfg.scene_path,
                        scan_id=scan_id,
                        scene_center=scene_center)


        relationship_save[scan_id] = relationships_json_string
        objects_save[scan_id] = {"objects_info": objects_info,
                                    "inst_to_label" : inst_labels}

        print ('==> DONE')
        print('SCENE ', scan_id)
        print('OBJECTS ', len(ObjNode_dict))

        scan_path = cfg.rels_save_path / scan_id

        scan_path.mkdir(parents=True, exist_ok=True)
        print('SAVE', scan_path)
        with (scan_path / 'relationships.json').open('w') as file:
            json.dump(relationship_save, file, default=default_dump)
        with (scan_path / 'objects.json').open('w') as file:
            json.dump(objects_save, file, default=default_dump)
        print ('=====================\n')


if __name__ == '__main__':
    cfg = OmegaConf.create({
        'dataset': 'dataset',
        'scene_path': '/path/to/dir',
        'rels_save_path': '/output/path/to/dir',
        'visualize': True,
        'num_workers': 1,
    })

    cfg.scene_path = Path(cfg.scene_path) / cfg.dataset / 'scan_data'
    cfg.rels_save_path = Path(cfg.rels_save_path) / cfg.dataset

    main(cfg)