processor/pointcloud.py

import random
from collections import Counter

import cv2
import matplotlib
import numpy as np
import open3d as o3d
import torch
from osdsynth.processor.wrappers.metric3d_v2 import get_depth_model, inference_depth
from osdsynth.processor.wrappers.perspective_fields import (
    create_rotation_matrix,
    get_perspective_fields_model,
    run_perspective_fields_model,
)
from PIL import Image
from scipy.spatial.transform import Rotation
from wis3d import Wis3D


class PointCloudReconstruction:
    """Class to reconstruct point cloud from depth maps."""

    def __init__(self, cfg, logger, device, init_models=True):
        """Initialize the class."""
        self.cfg = cfg
        self.logger = logger
        self.device = device
        self.vis = self.cfg.vis

        if init_models:
            # Initialize the perspective_fields_model
            self.perspective_fields_model = get_perspective_fields_model(cfg, device)

            # Initialize the Camera Intrinsics Model
            self.wilde_camera_model = torch.hub.load("osdsynth/external/WildCamera", "WildCamera", pretrained=True,source='local').to(device)

            # Initialize the Metric3D_v2
            self.depth_model = get_depth_model(device)
        else:
            self.perspective_fields_model = self.wilde_camera_model = self.depth_model = None

    def process(self, filename, image_bgr, detections_list):
        """Reconstruct point cloud from depth map."""

        image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)
        image_rgb_pil = Image.fromarray(image_rgb)

        # Run Perspective Fields, this returns the pitch, roll
        (
            vis_perspective_fields,
            perspective_fields,
        ) = run_perspective_fields_model(self.perspective_fields_model, image_bgr)

        # Perspective Fields to Rotation Matrix
        perspective_R = create_rotation_matrix(
            roll=perspective_fields["roll"],
            pitch=perspective_fields["pitch"],
            yaw=0,
            degrees=True,
        )

        # Infer camera intrinsics
        intrinsic, _ = self.wilde_camera_model.inference(image_rgb_pil, wtassumption=False)

        # Infer depth
        metric_depth = inference_depth(image_rgb, intrinsic, self.depth_model)

        # Depth to points
        pts3d = depth_to_points(metric_depth[None], intrinsic=intrinsic)
        cano_pts3d = depth_to_points(metric_depth[None], R=perspective_R.T, intrinsic=intrinsic)

        # Translate the points to ground
        cano_pts3d_flattened = cano_pts3d.reshape(-1, 3)
        sorted_flattened_points = cano_pts3d_flattened[cano_pts3d_flattened[:, 2].argsort()]
        fifty_percent_index = int(sorted_flattened_points.shape[0] * 0.5)
        selected_nearest_points = sorted_flattened_points[:fifty_percent_index]
        min_y = np.min(selected_nearest_points[:, 1])
        cano_pts3d[:, :, 1] -= min_y
        
        max_x = np.max(cano_pts3d[:, :, 0])
        min_x = np.min(cano_pts3d[:, :, 0])
        max_z = np.max(cano_pts3d[:, :, 2])
        min_z = np.min(cano_pts3d[:, :, 2])
        xz_max_min = [max_x, min_x, max_z, min_z]

        if self.vis:
            wis3d = Wis3D(self.cfg.wis3d_folder, filename)
            # wis3d.add_point_cloud(vertices=pts3d.reshape((-1, 3)), colors=image_rgb.reshape(-1, 3), name="pts3d")
            wis3d.add_point_cloud(
                vertices=cano_pts3d.reshape((-1, 3)), colors=image_rgb.reshape(-1, 3), name="cano_pts3d"
            )

        

        ### Create object points ###
        n_objects = len(detections_list)

        for obj_idx in range(n_objects):
            if detections_list[obj_idx]["xyxy"][0] > cano_pts3d.shape[1]:
                detections_list[obj_idx]["xyxy"][0] = cano_pts3d.shape[1]-1
            if detections_list[obj_idx]["xyxy"][1] > cano_pts3d.shape[0]:
                detections_list[obj_idx]["xyxy"][1] = cano_pts3d.shape[0]-1
            if detections_list[obj_idx]["xyxy"][2] > cano_pts3d.shape[1]:
                detections_list[obj_idx]["xyxy"][2] = cano_pts3d.shape[1]-1
            if detections_list[obj_idx]["xyxy"][3] > cano_pts3d.shape[0]:
                detections_list[obj_idx]["xyxy"][3] = cano_pts3d.shape[0]-1
                
            bbox = detections_list[obj_idx]["xyxy"]
            
            detections_list[obj_idx]["left_edge"] = -cano_pts3d[int((int(bbox[1])+int(bbox[3]))/ 2)][0][0]
            detections_list[obj_idx]["right_edge"] = -cano_pts3d[int((int(bbox[1])+int(bbox[3]))/ 2)][-1][0]

            detections_list[obj_idx]["square"] = np.abs((int(bbox[1])-int(bbox[3]))*(int(bbox[0])-int(bbox[2])))
            
            xc = int(intrinsic[0, 2])
            yc = int(intrinsic[1, 2])
            detections_list[obj_idx]["f"] = cano_pts3d[yc][xc] * 1000
            
            mask = detections_list[obj_idx]["subtracted_mask"]
            class_name = detections_list[obj_idx]["class_name"]

            object_pcd = create_object_pcd(cano_pts3d, image_rgb, mask)

            # The object should at least contains 5 points
            if len(object_pcd.points) < max(self.cfg.min_points_threshold, 5):
                print("camera_object_pcd points less than threshold, skip this detection")
                continue

            object_pcd = process_pcd(self.cfg, object_pcd)

            if len(object_pcd.points) < self.cfg.min_points_threshold_after_denoise:
                print(f"{class_name} pcd_bbox too less points ({len(object_pcd.points)}), skip this detection")
                continue

            axis_aligned_bbox, oriented_bbox = get_bounding_box(self.cfg, object_pcd)

            if axis_aligned_bbox.volume() < 1e-6:
                print(f"{class_name} pcd_bbox got small volume, skip this detection")
                continue

            detections_list[obj_idx]["pcd"] = object_pcd
            detections_list[obj_idx]["axis_aligned_bbox"] = axis_aligned_bbox
            detections_list[obj_idx]["oriented_bbox"] = oriented_bbox

        # Filter detections to include only those with a 'pcd' key
        filtered_detections = [det for det in detections_list if "pcd" in det]

        instance_colored_pcds = color_by_instance([det["pcd"] for det in filtered_detections])
        axis_aligned_bbox = [det["axis_aligned_bbox"] for det in filtered_detections]
        oriented_bboxes = [det["oriented_bbox"] for det in filtered_detections]

        if self.vis:
            obj_id = 0
            for obj_pcd, obj_aa_box, obj_or_box in zip(instance_colored_pcds, axis_aligned_bbox, oriented_bboxes):
                class_name = filtered_detections[obj_id]["class_name"]
                pcd_points = np.asarray(obj_pcd.points)
                pcd_colors = np.asarray(obj_pcd.colors)

                # Convert bbox to center, euler, extent
                aa_center, aa_eulers, aa_extent = axis_aligned_bbox_to_center_euler_extent(
                    obj_aa_box.get_min_bound(), obj_aa_box.get_max_bound()
                )
                or_center, or_eulers, or_extent = oriented_bbox_to_center_euler_extent(
                    obj_or_box.center, obj_or_box.R, obj_or_box.extent
                )

                wis3d.add_point_cloud(vertices=pcd_points, colors=pcd_colors, name=f"{obj_id:02d}_{class_name}")
                wis3d.add_boxes(
                    positions=aa_center, eulers=aa_eulers, extents=aa_extent, name=f"{obj_id:02d}_{class_name}_aa_bbox"
                )
                # wis3d.add_boxes(positions=or_center, eulers=or_eulers, extents=or_extent, name=f"{obj_id:02d}_{class_name}_or_bbox")
                obj_id += 1

        angles = [perspective_fields["roll"],perspective_fields["pitch"]]
        return filtered_detections, angles, xz_max_min


def depth_to_points(depth, R=None, t=None, fov=None, intrinsic=None):
    K = intrinsic
    Kinv = np.linalg.inv(K)
    if R is None:
        R = np.eye(3)
    if t is None:
        t = np.zeros(3)

    # M converts from your coordinate to PyTorch3D's coordinate system
    M = np.eye(3)

    height, width = depth.shape[1:3]

    x = np.arange(width)
    y = np.arange(height)
    coord = np.stack(np.meshgrid(x, y), -1)
    coord = np.concatenate((coord, np.ones_like(coord)[:, :, [0]]), -1)  # z=1
    coord = coord.astype(np.float32)
    coord = coord[None]  # bs, h, w, 3

    D = depth[:, :, :, None, None]
    pts3D_1 = D * Kinv[None, None, None, ...] @ coord[:, :, :, :, None]
    # pts3D_1 live in your coordinate system. Convert them to Py3D's
    pts3D_1 = M[None, None, None, ...] @ pts3D_1
    # from reference to targe tviewpoint
    pts3D_2 = R[None, None, None, ...] @ pts3D_1 + t[None, None, None, :, None]

    # G converts from your coordinate to PyTorch3D's coordinate system
    G = np.eye(3)
    G[0, 0] = -1.0
    G[1, 1] = -1.0

    return pts3D_2[:, :, :, :3, 0][0] @ G.T


def create_object_pcd(image_points, image_rgb, mask):
    points = image_points[mask]
    colors = image_rgb[mask] / 255.0

    # Perturb the points a bit to avoid colinearity
    points += np.random.normal(0, 4e-3, points.shape)

    # Create an Open3D PointCloud object
    pcd = o3d.geometry.PointCloud()
    pcd.points = o3d.utility.Vector3dVector(points)
    pcd.colors = o3d.utility.Vector3dVector(colors)
    return pcd


def get_bounding_box(cfg, pcd):
    axis_aligned_bbox = pcd.get_axis_aligned_bounding_box()

    try:
        oriented_bbox = pcd.get_oriented_bounding_box(robust=True)
    except RuntimeError as e:
        print(f"Met {e}.")
        oriented_bbox = None

    return axis_aligned_bbox, oriented_bbox


def points_to_pcd(points, colors=None):
    pcd = o3d.geometry.PointCloud()
    pcd.points = o3d.utility.Vector3dVector(points.reshape(-1, 3))
    if colors is not None:
        pcd.colors = o3d.utility.Vector3dVector(colors.reshape(-1, 3))
    return pcd


def process_pcd(cfg, pcd, run_dbscan=True):
    scale = np.linalg.norm(np.asarray(pcd.points).std(axis=0)) * 3.0 + 1e-6
    [pcd, _] = pcd.remove_statistical_outlier(nb_neighbors=20, std_ratio=2)
    pcd = pcd.voxel_down_sample(voxel_size=max(0.01, scale / 40))

    if cfg.dbscan_remove_noise and run_dbscan:
        # print("Before dbscan:", len(pcd.points))
        pcd = pcd_denoise_dbscan(pcd, eps=cfg.dbscan_eps, min_points=cfg.dbscan_min_points)  #
        # print("After dbscan:", len(pcd.points))

    return pcd


def pcd_denoise_dbscan(pcd: o3d.geometry.PointCloud, eps=0.02, min_points=10) -> o3d.geometry.PointCloud:
    ### Remove noise via clustering
    pcd_clusters = pcd.cluster_dbscan(
        eps=eps,
        min_points=min_points,
    )

    # Convert to numpy arrays
    obj_points = np.asarray(pcd.points)
    obj_colors = np.asarray(pcd.colors)
    pcd_clusters = np.array(pcd_clusters)

    # Count all labels in the cluster
    counter = Counter(pcd_clusters)

    # Remove the noise label
    if counter and (-1 in counter):
        del counter[-1]

    if counter:
        # Find the label of the largest cluster
        most_common_label, _ = counter.most_common(1)[0]

        # Create mask for points in the largest cluster
        largest_mask = pcd_clusters == most_common_label

        # Apply mask
        largest_cluster_points = obj_points[largest_mask]
        largest_cluster_colors = obj_colors[largest_mask]

        # If the largest cluster is too small, return the original point cloud
        if len(largest_cluster_points) < 5:
            return pcd

        # Create a new PointCloud object
        largest_cluster_pcd = o3d.geometry.PointCloud()
        largest_cluster_pcd.points = o3d.utility.Vector3dVector(largest_cluster_points)
        largest_cluster_pcd.colors = o3d.utility.Vector3dVector(largest_cluster_colors)

        pcd = largest_cluster_pcd

    return pcd


def create_object_pcd(image_points, image_rgb, mask):
    points = image_points[mask]
    colors = image_rgb[mask] / 255.0

    # Perturb the points a bit to avoid colinearity
    points += np.random.normal(0, 4e-3, points.shape)

    # Create an Open3D PointCloud object
    pcd = o3d.geometry.PointCloud()
    pcd.points = o3d.utility.Vector3dVector(points)
    pcd.colors = o3d.utility.Vector3dVector(colors)
    return pcd


def color_by_instance(pcds):
    cmap = matplotlib.colormaps.get_cmap("turbo")
    instance_colors = cmap(np.linspace(0, 1, len(pcds)))
    for i in range(len(pcds)):
        pcd = pcds[i]
        pcd.colors = o3d.utility.Vector3dVector(np.tile(instance_colors[i, :3], (len(pcd.points), 1)))
    return pcds


def oriented_bbox_to_center_euler_extent(bbox_center, box_R, bbox_extent):
    center = np.asarray(bbox_center)
    extent = np.asarray(bbox_extent)
    eulers = Rotation.from_matrix(box_R.copy()).as_euler("XYZ")
    return center, eulers, extent


def axis_aligned_bbox_to_center_euler_extent(min_coords, max_coords):
    # Calculate the center
    center = tuple((min_val + max_val) / 2.0 for min_val, max_val in zip(min_coords, max_coords))

    # Euler angles for an axis-aligned bounding box are always 0
    eulers = (0, 0, 0)

    # Calculate the extents
    extent = tuple(max_val - min_val for min_val, max_val in zip(min_coords, max_coords))

    return center, eulers, extent


# Distance calculations
def human_like_distance(distance_meters):
    # Define the choices with units included, focusing on the 0.1 to 10 meters range
    if distance_meters < 1:  # For distances less than 1 meter
        choices = [
            (
                round(distance_meters * 100, 2),
                "centimeters",
                0.2,
            ),  # Centimeters for very small distances
            (
                round(distance_meters * 39.3701, 2),
                "inches",
                0.8,
            ),  # Inches for the majority of cases under 1 meter
        ]
    elif distance_meters < 3:  # For distances less than 3 meters
        choices = [
            (round(distance_meters, 2), "meters", 0.5),
            (
                round(distance_meters * 3.28084, 2),
                "feet",
                0.5,
            ),  # Feet as a common unit within indoor spaces
        ]
    else:  # For distances from 3 up to 10 meters
        choices = [
            (
                round(distance_meters, 2),
                "meters",
                0.7,
            ),  # Meters for clarity and international understanding
            (
                round(distance_meters * 3.28084, 2),
                "feet",
                0.3,
            ),  # Feet for additional context
        ]

    # Normalize probabilities and make a selection
    total_probability = sum(prob for _, _, prob in choices)
    cumulative_distribution = []
    cumulative_sum = 0
    for value, unit, probability in choices:
        cumulative_sum += probability / total_probability  # Normalize probabilities
        cumulative_distribution.append((cumulative_sum, value, unit))

    # Randomly choose based on the cumulative distribution
    r = random.random()
    for cumulative_prob, value, unit in cumulative_distribution:
        if r < cumulative_prob:
            return f"{value} {unit}"

    # Fallback to the last choice if something goes wrong
    return f"{choices[-1][0]} {choices[-1][1]}"


def calculate_distances_between_point_clouds(A, B):
    dist_pcd1_to_pcd2 = np.asarray(A.compute_point_cloud_distance(B))
    dist_pcd2_to_pcd1 = np.asarray(B.compute_point_cloud_distance(A))
    combined_distances = np.concatenate((dist_pcd1_to_pcd2, dist_pcd2_to_pcd1))
    avg_dist = np.mean(combined_distances)
    return human_like_distance(avg_dist)


def calculate_centroid(pcd):
    """Calculate the centroid of a point cloud."""
    points = np.asarray(pcd.points)
    centroid = np.mean(points, axis=0)
    return centroid


def calculate_relative_positions(centroids):
    """Calculate the relative positions between centroids of point clouds."""
    num_centroids = len(centroids)
    relative_positions_info = []

    for i in range(num_centroids):
        for j in range(i + 1, num_centroids):
            relative_vector = centroids[j] - centroids[i]

            distance = np.linalg.norm(relative_vector)
            relative_positions_info.append(
                {"pcd_pair": (i, j), "relative_vector": relative_vector, "distance": distance}
            )

    return relative_positions_info


def get_bounding_box_height(pcd):
    """
    Compute the height of the bounding box for a given point cloud.

    Parameters:
    pcd (open3d.geometry.PointCloud): The input point cloud.

    Returns:
    float: The height of the bounding box.
    """
    aabb = pcd.get_axis_aligned_bounding_box()
    return aabb.get_extent()[1]  # Assuming the Y-axis is the up-direction


def compare_bounding_box_height(pcd_i, pcd_j):
    """
    Compare the bounding box heights of two point clouds.

    Parameters:
    pcd_i (open3d.geometry.PointCloud): The first point cloud.
    pcd_j (open3d.geometry.PointCloud): The second point cloud.

    Returns:
    bool: True if the bounding box of pcd_i is taller than that of pcd_j, False otherwise.
    """
    height_i = get_bounding_box_height(pcd_i)
    height_j = get_bounding_box_height(pcd_j)

    return height_i > height_j

def get_square(point_1, point_2):
    """Calculate the square of the distance between two points."""
    return (point_1[0]-point_2[0]) * (point_1[1]-point_2[1])

def get_focal_length(intrinsic, c_point):
    """Calculate the focal length from the intrinsic matrix."""
    xc = intrinsic[0, 2]
    yc = intrinsic[1, 2]
    
    
    return f