docs: update README with icp-flow in the official implementation.

* conf(optimization-based): update all config files.
* todo: update model file, double check with yancong and Qingwen confirm that: icp-flow results can be reproduced and tested.

Author: Kin-Zhang

README.md

@@ -31,6 +31,11 @@ International Conference on Robotics and Automation (**ICRA**) 2025
 European Conference on Computer Vision (**ECCV**) 2024  
 [ Strategy ] [ Self-Supervised ] - [ [arXiv](https://arxiv.org/abs/2407.01702) ] [ [Project](https://github.com/KTH-RPL/SeFlow) ] → [here](#seflow)
 
+- **ICP-Flow: LiDAR Scene Flow Estimation with ICP**  
+*Yancong Lin, Holger Caesar*  
+Conference on Computer Vision and Pattern Recognition (**CVPR**) 2024
+[ Optimization-based ] [ Self-Supervised ] - [ [arXiv](https://arxiv.org/abs/2402.17351) ] [ [Project](https://github.com/yanconglin/ICP-Flow) ] → [here](#icp-flow)
+
 - **DeFlow: Decoder of Scene Flow Network in Autonomous Driving**  
 *Qingwen Zhang, Yi Yang, Heng Fang, Ruoyu Geng, Patric Jensfelt*  
 International Conference on Robotics and Automation (**ICRA**) 2024  
@@ -45,7 +50,6 @@ Additionally, *OpenSceneFlow* integrates following excellent works: [ICLR'24 Zer
 - [x] [ZeroFlow](https://arxiv.org/abs/2305.10424): ICLR 2024, their pre-trained weight can covert into our format easily through [the script](tools/zerof2ours.py).
 - [x] [NSFP](https://arxiv.org/abs/2111.01253): NeurIPS 2021, faster 3x than original version because of [our CUDA speed up](assets/cuda/README.md), same (slightly better) performance.
 - [x] [FastNSF](https://arxiv.org/abs/2304.09121): ICCV 2023. SSL optimization-based.
-- [ ] [ICP-Flow](https://arxiv.org/abs/2402.17351): CVPR 2024. SSL optimization-based. Done coding, public after review.
 
 </details>
 
@@ -143,7 +147,7 @@ wget https://huggingface.co/kin-zhang/OpenSceneFlow/resolve/main/flow4d_best.ckp
 
 ### SSF
 
-Extra pakcges needed for SSF model:
+Extra packages needed for SSF model:
 ```bash
 pip install mmengine-lite torch-scatter
 # torch-scatter might not working, then reinstall by:
@@ -179,6 +183,21 @@ Pretrained weight can be downloaded through:
 wget https://huggingface.co/kin-zhang/OpenSceneFlow/resolve/main/seflow_best.ckpt
 ```
 
+### ICP-Flow
+
+ICP-Flow is a optimization-based method, you can directly run `eval.py`/`save.py` to get the result. 
+
+Extra packages needed for ICP-Flow model:
+```bash
+pip install pytorch3d assets/cuda/histlib
+```
+
+Then run as:
+```bash
+python eval.py model=icpflow
+python save.py model=icpflow
+```
+
 ### DeFlow
 
 Train DeFlow with the leaderboard submit config. [Runtime: Around 6-8 hours in 4x A100 GPUs.] Please change `batch_size&lr` accoordingly if you don't have enough GPU memory. (e.g. `batch_size=6` for 24GB GPU)
@@ -327,6 +346,12 @@ And our excellent collaborators works contributed to this codebase also:
   journal={arXiv preprint arXiv:2501.17821},
   year={2025}
 }
+@article{lin2024icp,
+  title={ICP-Flow: LiDAR Scene Flow Estimation with ICP},
+  author={Lin, Yancong and Caesar, Holger},
+  booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
+  year={2024}
+}
 ```
 
 Thank you for your support! ❤️

assets/cuda/histlib/__init__.py

@@ -0,0 +1,71 @@
+from torch import nn
+from torch.autograd import Function
+import torch
+import importlib
+
+import os, time
+import hist
+
+def histf(X, Y, min_x, min_y, min_z, max_x, max_y, max_z, len_x, len_y, len_z, mini_batch=8):
+    # print('hist cuda params: ', X.shape, Y.shape,
+    #       min_x, min_y, min_z,
+    #       max_x, max_y, max_z,
+    #       len_x, len_y, len_z,
+    #       )
+    histogram = hist.hist(X.contiguous(), Y.contiguous(), 
+                          min_x, min_y, min_z,
+                          max_x, max_y, max_z, 
+                          len_x, len_y, len_z, 
+                          mini_batch
+                          )
+    return histogram
+
+
+torch.manual_seed(2022)
+
+########################
+def run_test():
+    pts = torch.randn(3, 1000, 3)
+    indicators = torch.randint(0, 2, size=(3, 1000, 1))
+    pts1 = torch.cat([pts, indicators], dim=-1)
+    pts2  = pts1.clone()
+    pts2[:, :,0] += 5.
+    pts2[:, :,1] += -3.
+    pts2[:, :,2] += -0.2
+
+    range_x = 10.
+    range_y = 10.
+    range_z = 0.5
+    thres =0.1
+    # bins_x = torch.linspace(-range_x, range_x, int(2*range_x/thres)+1)
+    # bins_y = torch.linspace(-range_y, range_y, int(2*range_y/thres)+1)
+    # bins_z = torch.linspace(-range_z, range_z, int(2*range_z/thres)+1)
+    bins_x = torch.arange(-range_x, range_x+thres, thres)
+    bins_y = torch.arange(-range_y, range_y+thres, thres)
+    bins_z = torch.arange(-range_z, range_z+thres, thres)
+    print('bins_x: ', bins_x)
+    print('bins_z: ', bins_z)
+    pts1 = pts1.cuda()
+    pts2 = pts2.cuda()
+    bins_x = bins_x.cuda()
+    bins_y = bins_y.cuda()
+    bins_z = bins_z.cuda()
+
+    t_hists = histf(pts1, pts2, 
+               -range_x, -range_y, -range_z,
+               range_x, range_y, range_z,
+               len(bins_x), len(bins_y), len(bins_z),
+               )
+    print('output shape: ', t_hists.shape)
+    b, h, w, d = t_hists.shape
+    for t_hist in t_hists:
+        t_argmax = torch.argmax(t_hist)
+        print(f't_argmax: {t_argmax}, {t_hist.max()} {h}, {w}, {d}, {t_argmax//d//w%h}, {t_argmax//d%w}, {t_argmax%d}')
+        print('t_argmax', t_argmax//d//w%h, t_argmax//d%w, t_argmax%d, bins_x[t_argmax//d//w%h], bins_y[t_argmax//d%w], bins_z[t_argmax%d])
+
+if __name__ == '__main__':
+    
+    print("Pytorch version: ", torch.__version__)
+    print("GPU version: ", torch.cuda.get_device_name())
+    
+    run_test()

conf/model/fastnsf.yaml

@@ -13,5 +13,4 @@ target:
   early_patience: 10 # default is 10, set 30 to get better results
   point_cloud_range: [-51.2, -51.2, -3, 51.2, 51.2, 3]
 
-val_monitor: val/Dynamic/Mean
 iter_only: True

conf/model/icpflow.yaml

@@ -0,0 +1,17 @@
+name: icpflow
+
+target:
+  _target_: src.models.ICPFlow
+  thres_dist: 0.1
+  translation_frame: 1.67
+  chunk_size: 50
+  thres_iou: 0.2
+  max_points: 10000
+  min_cluster_size: 20
+  thres_box: 0.1
+  thres_rot: 0.1
+  thres_error: 0.2
+  speed: 1.67
+  point_cloud_range: [-51.2, -51.2, -3, 51.2, 51.2, 3]
+  
+iter_only: True

conf/model/nsfp.yaml

@@ -11,5 +11,4 @@ target:
   early_patience: 30 # default is 30, set 100 to get better results (zeroflow setting.)
   point_cloud_range: [-51.2, -51.2, -3, 51.2, 51.2, 3]
 
-val_monitor: val/Dynamic/Mean
 iter_only: True