Point clouds and 3D
LiDAR, meshes, registration and depth — representations where the choice of format decides what you can compute.
A point cloud is a set, not an array. There is no first point, no neighbouring cell, no guaranteed spacing, and usually no guarantee that two scans of the same wall contain a single point in common. Almost every difficulty in this field comes from that one property. Convolution assumes a grid, so it has to be given one; nearest-neighbour search assumes an index, so one has to be built; alignment assumes correspondences, so they have to be guessed and then re-guessed. The algorithms with names — ICP, RANSAC, Poisson reconstruction, voxel pooling — are each a specific answer to “what do I do with an unordered set of coordinates?”
These pages work from the representation outward. Pick a voxel grid and you inherit a memory bill that grows with the cube of resolution; keep raw points and you inherit a neighbourhood query on every operation; write to the wrong file format and you can lose classification codes, GPS time, or six centimetres of coordinate precision without a single error being raised. Where a number appears here it is either taken from a published specification, named and linked, or derived on the page from assumptions stated in the sentence that uses them.
Point Cloud Classification Explained
Why a network that reads an unordered set has to be built out of a symmetric function, and what max pooling over points actually keeps.
9 min read
3D Object Detection From LiDAR Point Clouds
How a sparse sweep becomes oriented 3D boxes: the voxelisation step, what fraction of the grid is actually occupied, and why range destroys recall.
10 min read
Point Cloud Segmentation Explained
What changes when the label moves from the whole cloud to every point: the receptive-field problem, boundary error, and why mIoU replaced accuracy.
9 min read
Structure From Motion: Building 3D From a Set of Photos
How unordered photographs become camera poses and a sparse point cloud, and why depth precision degrades with the square of distance.
10 min read
3D Mesh Reconstruction From Images
The classical route from photographs to a watertight surface — dense stereo, oriented normals, Poisson reconstruction — and where each stage silently invents geometry.
10 min read
Point Cloud Registration and Alignment Explained
How ICP finds the rigid transform between two overlapping scans, worked through the SVD step by hand, and why it needs a good initial guess.
11 min read
Voxel Grids and Point Clouds: Why the Representation You Pick Changes the Model
The memory arithmetic of the same scene stored two ways, why occupancy falls as you refine the grid, and what each representation makes computable.
9 min read
Estimating Depth From a Single Image
Why single-image depth is formally unsolvable, which pictorial cues a model exploits instead, and what an affine-invariant output can and cannot be used for.
10 min read
Point Cloud Compression: What Gets Traded Away
Storage arithmetic for a large survey archive under lossless and octree coding, and exactly which properties each method destroys.
10 min read
Fusing LiDAR and Camera Data for Perception
The coordinate transform that puts a LiDAR point on a pixel, worked end to end, plus the calibration and timing errors that make it wrong.
10 min read
3D Model Embeddings for Shape Similarity Search
How a mesh or scan becomes a vector you can index, the two families of encoder, and the invariances you have to choose deliberately.
9 min read
SLAM Explained: How a Robot Builds a Map While Finding Itself in It
The circular dependency at the centre of SLAM, a worked information-weighted pose update, and why loop closure is both the fix and the biggest risk.
10 min read
Point Cloud Density and Scan Resolution Trade-offs
Point spacing derived from angular step and range, file size and scan time at three settings, and the physical limit that makes the finest setting pointless.
9 min read
Building a Digital Twin From a 3D Scan
The geometry-capture-to-model pipeline, the error budget that accumulates across setups, and why a scan-derived twin is a dated record rather than a live one.
10 min read
What Processing a LiDAR Point Cloud Actually Costs
Compute, storage, egress and human time derived from a stated daily point volume — and which of the four actually dominates.
10 min read
Ground Plane Removal in Point Cloud Data
A runnable RANSAC plane-fitting script that separates ground from everything else, with the plane arithmetic worked by hand and the guards that stop it fitting a wall.
10 min read
Converting Between Point Cloud File Formats (LAS, PLY, PCD)
The errors you get converting between LAS, PLY and PCD, what each format can and cannot hold, and the float32 precision trap that loses half a metre silently.
11 min read
Detecting a Sparse or Noisy Region in a Point Cloud Before Processing
Tracing an invented surface in a reconstruction back to the sparse region that caused it, and the density gate that catches it before the expensive stage runs.
10 min read
Other topics
- LLM fundamentals & architecture
- Tokens, tokenization & context windows
- Prompt engineering
- Reasoning models & test-time compute
- Multimodal AI: vision, audio, video
- RAG & retrieval
- Embeddings & vector search
- AI agents & tool use
- Structured output & function calling
- Fine-tuning & post-training
- Local inference errors, string by string
- Running local models day to day
- Testing code that calls an LLM
- Snapshot and property testing for model output
- Regression suites for prompts
- Eval gates in CI
- Flaky tests against a model
- Determinism and the cost of testing
- Contract and streaming tests
- Testing tool calls and retrieval
- Inference, serving & latency
- Rolling out a prompt change
- Testing AI systems in practice
- Forecasting a time series
- Machine learning on tabular data
- Geospatial data and models
- Understanding audio that is not speech
- Understanding video
- Core computer vision tasks
- Machine learning on graphs
- Evaluation, benchmarks & LLM-as-judge
- Sensor and IoT data
- Logs and event streams
- Models over biological sequences
- Machine learning on molecules
- Embedding and searching code
- Extracting invoices and purchase orders
- Receipts, statements and tax forms
- Insurance policies and contracts
- Deeds, court filings and patents
- Extracting from medical records
- Observability & LLMOps
- CVs, certificates and identity documents
- Shipping, customs and technical documents
- Meetings, email, chat and filled-in forms
- Building an extraction pipeline
- Business, property and inspection documents
- Contract clauses and insurance claims
- Regulated and compliance documents
- Consumer, travel and closing documents
- Mapping one chat API onto another
- SDK and framework migrations
- Hallucination & failure modes
- Re-embedding and model deprecation
- Cutting over between providers
- Parity gaps, shims and legacy endpoints
- Moving between model versions
- Migrating vector stores and caches
- Mapping capabilities and parameters
- Migrating pipelines and agents
- Contracts, runbooks and rollback
- Auditing a codebase before a cutover
- Compliance and fine-tune migration
- LLM cost engineering
- Routing, cost tracking and multi-tenancy
- What a migration does to your prompts
- AI security & prompt injection
- Privacy, compliance & data residency
- AI governance, policy & society
- Building reliable AI applications
- AI hardware, GPUs & compute
- Open-weight models & local inference
- AI for developers & coding agents
- AI in industry: vertical playbooks
- AGI, superintelligence, alignment & the long future
- Machine learning foundations
- NLP fundamentals & classical tasks
- Data engineering for AI
- Synthetic data & dataset curation
- AI product design & UX
- Search, ranking & recommendation
- Enterprise adoption & change management
- AI careers, skills & teams
- Reading AI research
- AI in science & discovery
- Robotics & embodied AI
- AI economics, markets & business models
- AI myths, hype & media literacy
- Context engineering
- Shipping AI features: patterns & anti-patterns
- Build it: end-to-end AI tutorials
- Python for AI: hands-on recipes
- TypeScript, React and the web
- Frameworks and SDKs
- Errors and troubleshooting
- AI facts, numbers and statistics
- The history of AI
- The maths behind AI
- Architectures beyond the transformer
- Reinforcement learning
- Diffusion and generative media
- Speech, audio and voice engineering
- Benchmarks, one at a time
- AI search visibility
- Infrastructure and operations
- Databases and storage for AI
- Knowledge graphs and structured knowledge
- Classical ML in production
- Regulation, jurisdiction by jurisdiction
- Prompt recipes and pattern library
- AI for people who do not write code
- Writing, media and creative work
- Edge and on-device AI
- Interpretability and model internals
- Field notes
- OpenAI model behaviour
- Claude model behaviour
- Gemini model behaviour
- Llama model behaviour
- Mistral model behaviour
- Qwen model behaviour
- DeepSeek model behaviour
- Cohere model behaviour
- Grok model behaviour
- Small model behaviour
- Hybrid model architectures
- Token cost by language and script
- Transliteration, romanization and script handling
- Locale-correct output
- Multilingual generation quality
- Multilingual pipelines
- The EU AI Act, article by article
- AI under the GDPR and EU data law
- US AI regulation, state and sector
- International AI governance and standards
- AI litigation and enforcement
- Running AI workloads on AWS
- Running AI workloads on Google Cloud
- Running AI workloads on Azure
- AI at the edge: Workers, Vercel and Netlify
- Serving models on Kubernetes
- Operating AI infrastructure
- Quantization formats and what they cost
- llama.cpp, flag by flag
- Ollama and the desktop local-model runtimes
- Local models on Apple Silicon
- Hardware for local inference
- Running speech and embedding models locally
- Model files, adapters and conversion
- VRAM arithmetic for local models