Hi, can you help me? I come across the problem when I run train.py: Traceback (most recent call last): File "F:/github/Density_aware_Chamfer_Distance-main/train.py", line 287, in train() File "F:/github/Density_aware_Chamfer_Distance-main/train.py", line 59, in train model_module = importlib.import_module('.%s' % args.model_name, 'models') File "D:\IDE\Anaconda\envs\dcd\lib\importlib_init_.py", line 127, in import_module return _bootstrap._gcd_import(name[level:], package, level) File "", line 1006, in _gcd_import File "", line 983, in _find_and_load File "", line 967, in _find_and_load_unlocked File "", line 677, in _load_unlocked File "", line 728, in exec_module File "", line 219, in _call_with_frames_removed File "F:\github\Density_aware_Chamfer_Distance-main\models\vrcnet.py", line 7, in from utils.model_utils import * File "F:\github\Density_aware_Chamfer_Distance-main\utils\model_utils.py", line 13, in import utils.Pointnet2_PyTorch.pointnet2.pointnet2_utils as pn2 File "F:\github\Density_aware_Chamfer_Distance-main\utils\Pointnet2_PyTorch\pointnet2\pointnet2_utils.py", line 9, in import pointnet2_cuda as pointnet2 ModuleNotFoundError: No module named 'pointnet2_cuda'

Process finished with exit code 1

Hi, Congratulate for your great work！I think there is a typo in the paper. under Equation (9)，according to my understanding， it should be

\begin{aligned}
d_{D C D-E}\left(S_{1}, S_{2}\right) &=\frac{1}{2\left|S_{1}\right|} \sum_{x \in S_{1}}\left(1-\frac{1}{\max \left(n_{\hat{y}}/\eta, 1\right)} e^{-\alpha\|x-\hat{y}\|_{2}}\right) \\
&+\frac{1}{2\left|S_{2}\right|} \sum_{y \in S_{2}}\left(1-\frac{1}{\bar{\eta} \cdot n_{\hat{x}}} \sum_{\hat{x} \in N(y)_{\bar{\eta}}} e^{-\alpha\|y-\hat{x}\|_{2}}\right) .
\end{aligned}

Thank you for sharing your work. In this PR, I modified the weighting part in calc_dcd() to a batched manner. Although the memory consumption may increase, the speed is much faster! This PR only modifies utils_v2/ because I have an issue with compiling utils/.

The attached scripts gave the following results with my machine.

orig: 6.357818365097046 [s] # original
new : 0.5714225769042969 [s] # with this PR
dcd_orig=tensor([0.5886, 0.5782, 0.5761, 0.5773, 0.5795, 0.5833, 0.5820, 0.5802, 0.5821,
        0.5912, 0.5872, 0.5813, 0.5801, 0.5830, 0.5833, 0.5876],
       device='cuda:0')
dcd_new=tensor([0.5886, 0.5782, 0.5761, 0.5773, 0.5795, 0.5833, 0.5820, 0.5802, 0.5821,
        0.5912, 0.5872, 0.5813, 0.5801, 0.5830, 0.5833, 0.5876],
       device='cuda:0')

import time

import torch

from utils_v2.model_utils import calc_cd
from utils_v2.model_utils import calc_dcd as calc_dcd_orig


def calc_dcd_new(x, gt, alpha=1000, n_lambda=1, return_raw=False, non_reg=False):
    x = x.float()
    gt = gt.float()
    _, n_x, _ = x.shape
    _, n_gt, _ = gt.shape
    assert x.shape[0] == gt.shape[0]

    if non_reg:
        frac_12 = max(1, n_x / n_gt)
        frac_21 = max(1, n_gt / n_x)
    else:
        frac_12 = n_x / n_gt
        frac_21 = n_gt / n_x
    cd_p, cd_t, dist1, dist2, idx1, idx2 = calc_cd(x, gt, return_raw=True)
    # dist1 (batch_size, n_gt): a gt point finds its nearest neighbour x' in x;
    # idx1  (batch_size, n_gt): the idx of x' \in [0, n_x-1]
    # dist2 and idx2: vice versa
    exp_dist1, exp_dist2 = torch.exp(-dist1 * alpha), torch.exp(-dist2 * alpha)

    # batched!
    count1 = torch.zeros_like(idx2)
    count1.scatter_add_(1, idx1.long(), torch.ones_like(idx1))
    weight1 = count1.gather(1, idx1.long()).float().detach() ** n_lambda
    weight1 = (weight1 + 1e-6) ** (-1) * frac_21
    loss1 = (1 - exp_dist1 * weight1).mean(dim=1)

    # batched!
    count2 = torch.zeros_like(idx1)
    count2.scatter_add_(1, idx2.long(), torch.ones_like(idx2))
    weight2 = count2.gather(1, idx2.long()).float().detach() ** n_lambda
    weight2 = (weight2 + 1e-6) ** (-1) * frac_12
    loss2 = (1 - exp_dist2 * weight2).mean(dim=1)

    loss = (loss1 + loss2) / 2

    res = [loss, cd_p, cd_t]
    if return_raw:
        res.extend([dist1, dist2, idx1, idx2])

    return res


pc_1 = torch.randn([16, 2048, 3]).cuda() * 0.1
pc_2 = torch.randn([16, 2048, 3]).cuda() * 0.1

torch.cuda.synchronize()
start_t = time.time()
for _ in range(1000):
    dcd_orig, _, _ = calc_dcd_orig(pc_1, pc_2)
torch.cuda.synchronize()
print(f"orig: {time.time() - start_t} [s]")

torch.cuda.synchronize()
start_t = time.time()
for _ in range(1000):
    dcd_new, _, _ = calc_dcd_new(pc_1, pc_2)
torch.cuda.synchronize()
print(f"new : {time.time() - start_t} [s]")

print(f"{dcd_orig=}")
print(f"{dcd_new=}")

Hi, thanks for your instructive work! I think there is a typo in the paper. In the first line under Equation (4): \hat{y}=\min _{y \in S_{2}}\|x-y\|_{2}, I think it should be argmin instead.

Hi, thanks for your great work. When the points of two point-sets are different, does your calc_dcd() correspond to equation 8 or equation 9 in your paper? "We use Eqn. 8 in training for the loss between the coarse shape with 1024 points and the ground truth with 2048 points for simplicity." If it is corresponding to equation 8, how to deal with it when the loss value is negative？ Looking forward to your replay.

Hello, I was wondering how exactly is EMD measured on point clouds. When it's computed on probability distributions a transport plan is the weighted sum of the distances between two points and the "mass" transported between the two points, and EMD is the optimal transport plan.

Since point clouds are not really probability distributions I was wondering what are the weights of the weighted sum.