1 / 14

POINT CLOUD WORKSHOP

AT SVCU šŸŒ.

šŸŽ® A Comprehensive Introduction to 3D Data Analysis

šŸ‘¤ Presenter: Natapong Intarasuk

šŸŽ“ Institution: Chulalongkorn University

šŸ“§ Contact: int.natapong@gmail.com

šŸ™ GitHub: github.com/imtorrr

šŸ“‹ TODAY'S AGENDA

✨
Fundamentals
Understand what point clouds are and their unique properties
šŸ¤”
Challenges
Why 3D data is harder to analyze than 2D images
šŸ“Š
Analysis
Feature extraction and geometric descriptors
🧠
Deep Learning
PointNet and PointNet++ architectures

ā“ WHAT IS A POINT CLOUD?

Definition

A point cloud is an unstructured collection of 3D points in space, each defined by X, Y, Z coordinates.

Data Representation:

  • Format: 2D array shape (N, 3)
  • N = number of points
  • 3 = coordinate dimensions (X, Y, Z)

Beyond Geometry:

  • Intensity: Signal strength from sensors
  • RGB Color: Per-point color information
  • Timestamp: When each point was captured
  • Normal: Surface orientation vector

Acquisition Methods:

  • LiDAR scanning (airborne/terrestrial)
  • RGB-D cameras (Kinect, Intel RealSense)
  • Photogrammetry (SfM)
  • Structured light

šŸ’¾ FILE FORMAT COMPARISON

šŸ“„
ASCII Formats
.xyz, .txt, .csv

āœ… Human readable
āœ… Universal compatibility
āŒ Large file sizes
āŒ No metadata
āŒ Slow I/O
šŸ“¦
LAS/LAZ Formats
.las, .laz

āœ… Industry standard
āœ… Metadata support
āœ… Compression (LAZ)
āŒ Not human readable
āŒ Limited mesh support
šŸŽ®
Binary Formats
.ply, .e57, .obj, .npy

āœ… Flexible structure
āœ… Mesh + cloud
āœ… Fast I/O
āŒ Limited standard
āŒ Software dependent
File Format Comparison

šŸ¤” WHY IS 3D ANALYSIS HARDER?

šŸ—ļø UNSTRUCTURED DATA
Points are scattered irregularly in space with no inherent grid structure. Unlike 2D images with pixel grids, there's no built-in neighbor relationship. This breaks traditional CNN architectures designed for regular grids.
šŸ”„ PERMUTATION INVARIANCE
The order of points is irrelevant. A point cloud with points [P1, P2, P3] is identical to [P3, P1, P2]. This property requires special network architectures that can handle permutation-invariant operations.
šŸ“ SCALE AND TRANSLATION VARIANCE
A coffee cup and a building can have identical spatial structure — only coordinates differ. Networks must learn scale-invariant and translation-invariant features to distinguish meaningful patterns from absolute positions.
šŸ’¾ MEMORY & COMPUTATION
Point clouds can contain millions of points. Processing all points directly requires massive memory and computation. Efficient sampling and hierarchical methods are essential.

šŸ”— THE NEIGHBORHOOD CONCEPT

Key Insight

A single point's coordinates alone tell you nothing. Feature extraction happens by analyzing its local neighborhood.

šŸ“
Line Pattern
Neighbors aligned in a line → Edge, pole, or thin structure (eigenvalue: Ī»1 >> Ī»2, Ī»3)
šŸ“
Planar Pattern
Neighbors form a plane → Roof, wall, or flat surface (Ī»1 ā‰ˆ Ī»2 >> Ī»3)
🌳
Volume Pattern
Neighbors scattered 3D → Vegetation or dense cluster (Ī»1 ā‰ˆ Ī»2 ā‰ˆ Ī»3)
šŸŽÆ
Geometric Features
PCA eigenvalues reveal local geometry for classification

šŸ’” Feature extraction = Bridge from raw 3D data to machine intelligence

🌳 SPATIAL QUERIES & KD-TREES

Why spatial queries matter: Efficiently finding neighbors is critical for feature computation. Brute force O(n²) is impractical for million-point clouds.

šŸŽÆ K-Nearest Neighbors (KNN)
Goal: Find exactly K closest points to query point
Pros: Fixed neighborhood size, consistent density
Cons: Ignores scale, might include distant outliers
Typical K: 10-50 neighbors
Complexity: O(n log n) with KD-tree
ā­• Radius Search
Goal: Find all points within fixed radius
Pros: Physically meaningful, scale-aware
Cons: Variable neighbor count
Typical radius: 0.1-1.0 meters
Algorithm Insight

KD-tree partitions space recursively, reducing search from O(n) to O(log n) on average. Essential for real-time processing!

šŸ“Š COMPUTING GEOMETRIC FEATURES

Method: Principal Component Analysis (PCA)

After finding neighborhoods with KD-tree, extract shape descriptors via eigenvector analysis

Eigenvalue Analysis
Sort eigenvalues: λ₁ ≄ λ₂ ≄ Ī»ā‚ƒ

Linearity: (λ₁ - λ₂) / λ₁
Planarity: (λ₂ - Ī»ā‚ƒ) / λ₁
Scattering: Ī»ā‚ƒ / λ₁

Classify each point type!
Derived Features
Surface Normal: Smallest eigenvector
Curvature: Ī»ā‚ƒ / (λ₁ + λ₂ + Ī»ā‚ƒ)
Roughness: Deviation from plane
Verticality: Angle with Z-axis

Perfect for semantic labeling!

Typical Workflow:

ā˜ļø CLOUDCOMPARE: PRACTICAL WORKFLOW

Workflow Steps:

1ļøāƒ£ Import Data
Load LAS, PLY, XYZ, or other formats. Preview point count, density, and bounds.
2ļøāƒ£ Clean Data
Remove outliers, noise, and erroneous points using statistical filters.
3ļøāƒ£ Subsample
Reduce density with spatial subsampling to manage computational load.
4ļøāƒ£ Compute Features
Calculate normals, curvature, eigenvalues via PCA on neighbors.
5ļøāƒ£ Export Results
Save as CSV, PLY with computed features ready for ML pipelines.
CloudCompare interface

🧠 MACHINE LEARNING APPROACHES

Traditional Pipeline

Manual feature extraction → Classical ML (Random Forest, SVM, etc.) ← Works but requires domain expertise

Modern Deep Learning Pipeline

Raw point cloud → Neural network (PointNet/PointNet++) → Learned features → Classification ← Automatic & powerful

šŸ“š Key Resources for Learning:

šŸ“ PROPERTIES OF POINT SET IN ā„āæ

Permutation Invariance

Order of points doesn't matter. {P₁, Pā‚‚, Pā‚ƒ} = {Pā‚ƒ, P₁, Pā‚‚}. A good network should produce same output regardless of input order.

Translation Invariance

Shifting all points by the same vector shouldn't affect local geometric properties. Networks should be robust to coordinate shifts.

šŸŽÆ Global Structure
Aggregate local features via symmetry functions (max pooling, sum pooling) to capture global shape
šŸ”— Local Dependencies
Nearby points in 3D space relate to each other. Use neighborhoods (KNN, radius) to capture local structure
āš™ļø Rotation Sensitivity
Networks are generally NOT rotation invariant. Use data augmentation or alignment preprocessing
šŸ“Š Unordered Set
Points are unordered collection, not sequences. Requires symmetric aggregation functions

šŸ”“ POINTNET: REVOLUTIONIZING 3D LEARNING Open in Colab

Key Innovation:

Direct point cloud processing without voxelization

Processes raw (N, 3) point coordinates directly instead of converting to voxels or meshes. Maintains sparse nature of data.

Architecture:

  • Input: N Ɨ 3 point cloud
  • MLP on each point independently
  • Max pooling aggregation (permutation invariant!)
  • Global feature vector
  • Classification or segmentation head

Advantages:

  • Simple & elegant architecture
  • Permutation invariant aggregation
  • Direct on raw coordinates
  • Theoretically proven expressiveness

Limitations:

  • No local structure learning
  • Sensitive to outliers
  • Struggles with large point clouds
  • Limited contextual understanding

šŸ’” Breakthrough: Proved CNNs aren't necessary for 3D learning!

PointNet Architecture

šŸ“š Learn More:

🟢 POINTNET++: HIERARCHICAL LEARNING Open in Colab

Answer to PointNet's limitations: Learn hierarchical features at multiple scales

Multi-Scale Approach:

  • Set Abstraction Levels: Recursively partition space
  • PointNet++ learns: Local features at each level
  • Coarse-to-fine: Aggregate features bottom-up
  • Context modeling: Understand neighborhoods + global structure

Key Components:

  • Sampling layer (fps)
  • Grouping layer (KNN/radius)
  • PointNet feature extraction
  • Feature propagation on upsampling

Advantages Over PointNet:

  • Learns hierarchical features
  • Captures multi-scale structure
  • Better contextual understanding
  • More robust to noise
  • Superior segmentation accuracy

Use Cases:

  • Semantic segmentation (scene labeling)
  • Instance segmentation
  • Object detection in 3D
  • Fine-grained shape analysis

šŸ† State-of-the-art for most 3D understanding tasks

PointNet++ Architecture

šŸ“š KEY RESOURCES

LinkedIn
LinkedIn content
Youtube, Medium
Youtube Medium content
Udemy Course
Udemy content
Youtube
Youtube content

šŸŽ‰ Thank You!

Questions? Let's explore the fascinating world of 3D point clouds together!

Enlarged view