DenoiseNet

DenoiseNet is a neural network for classifying noise in point clouds. Given a raw, noisy point cloud, the model labels each point as either part of the underlying shape or as a noisy point that should be removed, leaving a cleaned-up point cloud as output.

This project was built for CS 752/852: Foundations of Neural Networks at the University of New Hampshire (Prof. Laura Dietz) by Justin Perkins and Joe Wilder.

Task

Point clouds show up across many domains (3D reconstruction, lidar/sonar scanning, visualization) but are commonly polluted with noisy, inaccurate points. Manually cleaning them up by hand doesn't scale.

• Input: a noisy point cloud of shape N x 3 (N points, each an x/y/z coordinate)
• Output: a per-point classification of shape N x 1 (noise vs. not noise)

Dataset

The dataset is synthetic, built from ModelNet10 (~4,000 mesh files across 10 object categories like chairs, sofas, and beds):

1. Sample a point cloud from each mesh file (ground truth, clean).
2. Inject synthetic noise points outside the object's bounding box/mesh, with non-uniform density and clustering to mimic real-world sensor noise (lidar, sonar, etc.) rather than pure random noise.
3. Label every point as clean or noisy.

This gives close to 5,000 noisy point clouds with ground-truth labels, split roughly 80% train / 20% test.

Models

The project explores progressively more sophisticated architectures for this task:

Model	Idea
Stacked Neighbors MLP	Stacks each point's k nearest neighbors onto it and runs it through a simple linear + ReLU layer.
MLP with Positionwise Pre-Predictions	Extends the stacked-neighbor MLP by first generating a pre-prediction for each neighbor (via a position-wise feed-forward layer) and feeding that signal back into the final prediction.
Pointwise Convolution	Uses 1D/pointwise convolutions to expand each point's features into higher dimensions (3 → 64 → 128 → 1024) and back down to a single prediction, independent of point ordering.
PointNet MLP	Implements a simplified PointNet with a T-Net alignment layer, learning both local (per-point) and global (max-pooled) features before classifying each point.

Results

Model	Train Accuracy	Test Accuracy	BCE Loss
MLP	0.8038	0.8038 ± 0.0000	0.4944
MLP with PFF Pre-Predictions	0.8038	0.8038 ± 0.0163	0.5219
Pointwise Convolution	0.8669	0.8607 ± 0.0015	0.3263
PointNet MLP	0.9609	0.9629 ± 0.0006	0.1037

The ~80% baseline reflects the natural ratio of clean to noisy points in the dataset, so the basic MLP variants essentially learn nothing useful. The PointNet-based model performs best, since it captures both local point-level context and global shape structure, and its T-Net layer helps make the model invariant to point ordering and transformations.

Repository Structure

.
├── Environment Setup/   # Setup notes/files for getting the project running
├── Notebooks/           # Jupyter notebooks: dataset generation, models, training, evaluation
├── Poster/              # Conference-style poster summarizing the project
├── Report/              # Full written report / project proposal
└── LICENSE

Getting Started

This project is tested with Python 3.11 on Windows 11.

1. Create a virtual environment

   python -m venv venv

   If python -V isn't reporting 3.11, install it from python.org and point the venv command at that specific python.exe instead.

2. Activate it

   .\venv\Scripts\activate

3. Install dependencies

   pip install -r requirements.txt

   This installs: requests, matplotlib, pandas, trimesh, open3d, torch, tqdm, scipy.

   If torch fails to install, remove it from requirements.txt and install it manually using the command from pytorch.org/get-started/locally.

4. Open the notebooks in VS Code

   Use Ctrl+Shift+P → Python: Select Interpreter to point VS Code at the new virtual environment, then do the same for Notebook: Select Notebook Kernel. Restart VS Code (or run Developer: Reload Window) if the kernel doesn't show up.

5. Run through the notebook

   The notebook will automatically download and cache the ModelNet10 dataset, build the synthetic noisy point cloud dataset (saved to a pickle file so it only needs to run once), train each model, and report accuracy/loss metrics.

Existing Approaches

Classical methods like the SOR (Statistical Outlier Removal) algorithm used in CloudCompare flag points as noise based on how far they sit from the average neighbor distance, scaled by a standard-deviation parameter. This works but requires manual parameter tuning per point cloud, which doesn't scale well to large or varied datasets — part of the motivation for a learned approach here.

References

• ModelNet10: https://modelnet.cs.princeton.edu/
• PointNet: Deep Learning on Point Sets for 3D Classification and Segmentation — https://arxiv.org/pdf/1612.00593

License

MIT