A C++ & Python viewer for 3D data like meshes and point clouds
Alternatives To Polyscope
Project NameStarsDownloadsRepos Using ThisPackages Using ThisMost Recent CommitTotal ReleasesLatest ReleaseOpen IssuesLicenseLanguage
6 hours ago64September 20, 2022138otherGo
Netmaker makes networks with WireGuard. Netmaker automates fast, secure, and distributed virtual networks.
Mosn4,095211 hours ago91August 23, 2022263apache-2.0Go
The Cloud-Native Network Proxy Platform
3 days ago177otherC++
CloudCompare main repository
a day ago239agpl-3.0C++
open Multi-View Stereo reconstruction library
Coolstore Microservices2,215
a month ago25mitC#
A full-stack .NET microservices build on Dapr and Tye
3 days ago75mitC++
A C++ & Python viewer for 3D data like meshes and point clouds
21 days ago6gpl-3.0C++
A lightweight, easy-to-use, and efficient C++ library for processing and rendering 3D data
Point Cloud Utils793
18 days ago29December 13, 202110gpl-2.0C++
A Python library for common tasks on 3D point clouds
5 months ago11mitPython
This repository contains the source codes for the paper "AtlasNet: A Papier-Mâché Approach to Learning 3D Surface Generation ". The network is able to synthesize a mesh (point cloud + connectivity) from a low-resolution point cloud, or from an image.
4 hours ago102apache-2.0JavaScript
Layer5, expect more from your infrastructure
Alternatives To Polyscope
Select To Compare

Alternative Project Comparisons

Polyscope's documentation is hosted at polyscope.run

To contribute, check out the instructions here.


actions status linux actions status macOS actions status windows PyPI

Polyscope is a C++/Python viewer and user interface for 3D data such as meshes and point clouds. It allows you to register your data and quickly generate informative and beautiful visualizations, either programmatically or via a dynamic GUI. Polyscope is designed to be lightweight---it does not "take ownership" over your entire program, and it is easy to integrate with existing codebases and popular libraries. The lofty objective of Polyscope is to offer a useful visual interface to your data via a single line of code.

Polyscope uses a paradigm of structures and quantities. A structure is a geometric object in the scene, such as a surface mesh or point cloud. A quantity is data associated with a structure, such as a scalar function or a vector field.

When any of these structures and quantities are registered, Polyscope displays them in an interactive 3D scene, handling boilerplate concerns such as toggling visibility, color-mapping data and adjusting maps, "picking" to click in the scene and query numerical quantities, etc.


#include "polyscope/polyscope.h"
#include "polyscope/surface_mesh.h"

// Initialize polyscope

// Register a point cloud
// `points` is a Nx3 array-like container of points
polyscope::registerPointCloud("my points", points)

// Register a surface mesh structure
// `meshVerts` is a Vx3 array-like container of vertex positions
// `meshFaces` is a Fx3 array-like container of face indices  
polyscope::registerSurfaceMesh("my mesh", meshVerts, meshFaces);

// Add a scalar and a vector function defined on the mesh
// `scalarQuantity` is a length V array-like container of values
// `vectorQuantity` is an Fx3 array-like container of vectors per face
polyscope::getSurfaceMesh("my mesh")->addVertexScalarQuantity("my_scalar", scalarQuantity);
polyscope::getSurfaceMesh("my mesh")->addFaceVectorQuantity("my_vector", vectorQuantity);

// View the point cloud and mesh we just registered in the 3D UI


import polyscope as ps

# Initialize polyscope

### Register a point cloud
# `my_points` is a Nx3 numpy array
ps.register_point_cloud("my points", my_points)

### Register a mesh
# `verts` is a Nx3 numpy array of vertex positions
# `faces` is a Fx3 array of indices, or a nested list
ps.register_surface_mesh("my mesh", verts, faces, smooth_shade=True)

# Add a scalar function and a vector function defined on the mesh
# vertex_scalar is a length V numpy array of values
# face_vectors is an Fx3 array of vectors per face
ps.get_surface_mesh("my mesh").add_scalar_quantity("my_scalar", 
        vertex_scalar, defined_on='vertices', cmap='blues')
ps.get_surface_mesh("my mesh").add_vector_quantity("my_vector", 
        face_vectors, defined_on='faces', color=(0.2, 0.5, 0.5))

# View the point cloud and mesh we just registered in the 3D UI

Polyscope is designed to make your life easier. It is simple to build, and fewer than 10 lines of code should be sufficient to start visualizing. In C++, some template magic means Polyscope can probably accept the data types you're already using!

Author: Nicholas Sharp

If Polyscope contributes to an academic publication, cite it as:

  title = {Polyscope},
  author = {Nicholas Sharp and others},
  note = {www.polyscope.run},
  year = {2019}

Development of this software was funded in part by NSF Award 1717320, an NSF graduate research fellowship, and gifts from Adobe Research and Autodesk, Inc.

Popular Cloud Computing Projects
Popular Mesh Projects
Popular Cloud Computing Categories

Get A Weekly Email With Trending Projects For These Categories
No Spam. Unsubscribe easily at any time.
C Plus Plus