For 3D modeling, geometry processing, and rendering, designed with emphasis on simplicity and efficiency.

Easy3D is implemented in C++ and comes with Python bindings. It is intended for research and educational purposes, but it is also a good starting point for developing sophisticated 3D applications. Compared to existing geometry processing libraries (such as PMP and libigl) that focus on the algorithm aspect, Easy3D also provides a wider range of functionalities for user interactions and rendering.

Key features

Efficient data structures for representing and managing 3D models such as point clouds, polygonal surfaces (e.g., triangle meshes), polyhedral volumes (e.g., tetrahedral meshes), and graphs. Easy to add/access arbitrary types of per-element properties. Non-manifoldness is automatically resolved when loading models from files ...
A set of widely used algorithms, e.g., point cloud normal estimation/re-orientation, Poisson surface reconstruction, RANSAC, mesh simplification, subdivision, smoothing, parameterization, remeshing, and more (the implementation of several surface mesh processing algorithms were taken from PMP).
A bunch of rendering techniques, e.g., point/line imposters, ambient occlusion (SSAO), hard shadow (shadow maps), soft shadow (PCSS), eye-dome lighting (for rendering point clouds without normal information), transparency (average color blending, dual depth peeling), and more.
High-level encapsulation of OpenGL and GLSL for convenient and efficient rendering (based on modern and faster programmable-shader-style rendering, i.e., no fixed function calls). Client code does not need to touch the low-level APIs of OpenGL.
Step-by-step tutorials demonstrating various uses of the API, to get acquainted with the data structures, rendering techniques, and algorithms for 3D modeling and geometry processing.
Very easy to use as a callable library (usually only a few lines of code).
A viewer that can be used directly to visualize 3D scenes in various formats, which can also be easily extended. For window/GUI creation, Easy3D currently supports GLFW (e.g., the default viewer), Qt (see the Qt viewer), and wxWidgets (see the wxWidgets viewer).
A handy tool Mapple created out of the Easy3D library for rendering and processing 3D data.
Python bindings for Easy3D, which allow you to use Easy3D in Python scripts.

| Scalar field | Polyhedral mesh | Keyframe animation | |------------------------------------------|-------------------------------------------|--------------------------------------------| | | | |

A glance

Any type of 3D drawables (e.g., points, lines, triangles, and thus point clouds, mesh surfaces, scalar fields, and vector fields) can be rendered by writing a few lines of code with Easy3D. For example, the following code renders a point cloud as a set of spheres

// assume your point cloud has been loaded to the viewer
PointsDrawable* drawable = cloud->renderer()->get_points_drawable("vertices");
drawable->set_impostor_type(PointsDrawable::SPHERE); // draw points as spheres.
drawable->set_point_size(3.0f);    // set point size

or as a set of surfels (i.e., 3D discs)

drawable->set_impostor_type(PointsDrawable::SURFEL);

By abstracting geometric elements as one of the above drawables, more general visualization (e.g., vector fields, scalar fields) can be done very conveniently.

Easy3D repository layout

The repository contains a CMakeLists.txt file (in the root directory of the repository) that serves as an anchor for configuring and building programs, as well as a set of subfolders:

3rd_party - source code of third-party libraries
applications - applications built on top of Easy3D
cmake - CMake-related configuration files
docs - documentation configuration file (Doxygen)
easy3d - source code of Easy3D, implementing the Easy3D modules:
- util - utilities, e.g., logging, file system, progress, timer.
- core - basic types and data structures, e.g., point cloud, surface mesh, graph, and polyhedron mesh.
- fileio - functionalities for reading/writing data from/into files.
- kdtree - a collection of kd-trees.
- algo - algorithms for geometry processing.
- algo_ext - several extended surface mesh processing algorithms (based on CGAL).
- video - a class that can encode an image sequence into a video.
- renderer - functionalities and algorithms for rendering and visualization.
- gui - tools for user interactions, e.g., picking points, faces, or models.
- viewer - a simple viewer and a composite viewer.
- python - Python bindings for Easy3D, and examples.
resources - test data, images, shaders, textures, etc.
tests - a collection of test cases
tutorials - a collection of examples (with detailed explanations in code)

Build Easy3D

Like most software, Easy3D depends on some third-party libraries. Easy3D has made this easier for users by including the source code of most third-party libraries (for the core functionalities and the basic viewer), and it leaves very few optional (for a few additional features that are typically not needed by most users).

The optional third-party libraries are:

CGAL (optional): Easy3D has implemented a few algorithms for advanced surface mesh processing, such as surface reorientation, detecting/resolving duplicate vertices/faces and self-intersection, and clipping/splitting/slicing surface meshes. These features are disabled by default (because most users don't need them). To enable these features, you can switch on the CMake option Easy3D_ENABLE_CGAL and make sure CGAL (v5.1 or later) is installed and visible to CMake. In case you have multiple versions of CGAL on your platform, simply provide the path of a suitable one to the CMake variable CGAL_DIR.
Qt (optional): Easy3D supports Qt >= v5.6 (v5.14.2, v5.12.12, and v6.7.3 have been tested) for UI creation, which can help develop sophisticated applications for 3D data processing and visualization. The Qt support is disabled by default (because most users don't need it). You can switch on the CMake option Easy3D_ENABLE_QT to include the examples and applications that depend on Qt (e.g., Tutorial_204_Viewer_Qt and Mapple).

To build Easy3D, you need CMake (>= 3.12) and, of course, a compiler that supports >= C++11.

Easy3D has been tested on macOS (Xcode >= 8), Windows (MSVC >=2015 x64), and Linux (GCC >= 4.8, Clang >= 3.3). Machines nowadays typically provide higher support, so you should be able to build Easy3D on almost all platforms.

There are many options to build Easy3D. Choose one of the following (not an exhaustive list):

Option 1 (purely on the command line): Use CMake to generate Makefiles and then make (on Linux/macOS) or nmake(on Windows with Microsoft Visual Studio).
- On Linux or macOS, you can simply
```
    $ cd path-to-root-dir-of-Easy3D
    $ mkdir Release
    $ cd Release
    $ cmake -DCMAKE_BUILD_TYPE=Release ..
    $ make
```
- On Windows with Microsoft Visual Studio, use the `x64

Easy3D

Install / Use

README

For 3D modeling, geometry processing, and rendering, designed with emphasis on simplicity and efficiency.

Key features

A glance

Easy3D repository layout

Build Easy3D