Lagrange is a comprehensive C++ geometry processing library focused on 3D mesh manipulation, analysis, and visualization. It provides a robust core mesh data structure (SurfaceMesh) with extensive algorithms for mesh processing including subdivision, simplification, cleaning, remeshing, and parameterization. The library features specialized modules for geodesic computation, texture processing, volume conversion, boolean operations, and more, along with UI/viewer components for interactive visualization and Python bindings for scripting. Built with a modular architecture using modern C++ template metaprogramming, it emphasizes algorithmic correctness through exact predicates and supports multiple mesh formats via Assimp integration.
This is a software library for parsing and processing IFC (Industry Foundation Classes) BIM files, primarily designed for web environments. It consists of a C++ core that reads IFC STEP files, resolves geometry (including extrusions, sweeps, Boolean CSG operations, and advanced curves like B-splines and clothoids), and generates triangulated meshes. The C++ code is compiled to WebAssembly via Emscripten, and a TypeScript API (IfcAPI) exposes all functionality to JavaScript applications in both browser and Node.js. The library supports multiple IFC schema versions (IFC2X3, IFC4, IFC4X3) and includes a schema generator that produces C++ and TypeScript type definitions from EXPRESS schema files. The architecture is a classic native-to-web bridge: the C++ library handles all heavy geometry and parsing, while the TypeScript layer provides a clean interface for loading models, streaming meshes, reading/writing properties, and creating new geometry. Key entry points include the IfcAPI class (open/close models, load geometry, save models), the C++ IfcGeometryProcessor and IfcGeometryLoader for mesh generation, and the IfcLoader for token-based IFC parsing. External dependencies include GLM (math), spdlog (logging), mapbox/earcut (triangulation), and CDT (constrained Delaunay triangulation). A comprehensive test suite using real IFC files and regression hash checks ensures geometry stability across versions. The library is production-ready but shows some technical drift: pinned dependency commits, large monolithic source files, and generated schema headers that must be manually regenerated. It remains actively maintained with CI/CD pipelines, issue triage, and regular releases (v0.0.78).
CuMesh is a GPU-accelerated library for high-performance 3D geometry processing within the PyTorch ecosystem. It provides efficient CUDA implementations for mesh cleaning, decimation, remeshing, and UV unwrapping. The library centers around the CuMesh class which manages mesh data on GPU and exposes operations through PyTorch tensor interfaces. Key components include a QEM-based mesh simplification algorithm, narrow-band dual contouring remeshing, accelerated mesh clustering for UV unwrapping, and comprehensive mesh connectivity queries. The implementation demonstrates strong GPU programming practices with proper memory management, error checking, and efficient use of primitives like CUB for parallel operations.
KiKit is a Python CLI tool, library, and KiCAD plugin for automating PCB panelization and fabrication output. It takes KiCAD board files (S-expression format) and produces panelized PCBs with v-cuts, mouse bites, tooling holes, fiducials, and frames. It also exports manufacturing files (Gerbers, drill, assembly data) tailored to popular fab houses (JLCPCB, PCBWay, OSH Park), generates 3D-printable solder paste stencils, performs DRC checks, and creates presentation pages for boards. The architecture is modular: core geometric operations use Shapely, interval algebra, and a custom S-expression parser; an extensible plugin system allows custom layout, tab, and cut strategies. The tool integrates deeply with KiCAD’s pcbnew API and supports multiple KiCAD versions (6–9) through version-specific adapters. While primarily a production tool for hardware engineers, its clean separation of parsing, geometry, and CLI makes several components reusable in other PCB-adjacent projects.
This repository is a comprehensive C++ library and suite of command-line tools for mesh processing research, originally developed by Hugues Hoppe at Microsoft Research. It implements algorithms from several SIGGRAPH papers (1992–2003), including surface reconstruction from unorganized points, mesh optimization, progressive meshes, view-dependent refinement, subdivision surface fitting, spherical parameterization, and gradient-domain video looping. The core library, libHh, provides a rich set of reusable data structures (e.g., fixed-size vectors, D-dimensional grids, half-edge meshes, progressive mesh representations) and algorithms (spatial search, least-squares solvers, multigrid, image filtering, parallel patterns). The tools are designed as stream-oriented filters that read from stdin and write to stdout, enabling Unix-style pipelines for complex processing workflows. An interactive OpenGL viewer (G3dOGL) supports real-time rendering with level-of-detail and geomorph transitions. The build system supports multiple platforms (Windows, Linux, macOS via Cygwin/MinGW) using GNU make and Visual Studio, with optional dependencies on libpng, libjpeg, and ffmpeg for media I/O. The codebase is well-tested with a comprehensive suite of unit and integration tests, and includes numerous demo scripts that reproduce published research results.
This repository provides a header-only C++ library with Python bindings for solving partial differential equations (PDEs) using Monte Carlo methods, specifically Walk on Spheres (WoS) and Walk on Stars (WoS★) algorithms. It supports Laplace, Poisson, and screened Poisson equations with Dirichlet, Neumann, and Robin boundary conditions in 2D and 3D. The library includes variance reduction techniques (Boundary Value Caching, Reverse Walk on Stars) and handles exterior problems via the Kelvin transform. It is designed for grid-free PDE solving, relying on geometric queries (via FCPW BVH or SDF grids) rather than volume meshing. The codebase is research-oriented, with clear reference implementations and citations to foundational papers, but includes many TODO comments and incomplete optimizations. The architecture is modular with template-based dimension and value type abstraction, making it adaptable but also complex. Demo applications in C++ and Python illustrate usage on model problems with JSON configuration and image output.