<p>There are plenty of algorithms for generating meshes from point clouds. I am going to suggest looking at the libraries <a href="https://doc.cgal.org/latest/Manual/tuto_reconstruction.html" rel="nofollow noreferrer">CGAL</a> and <a href="https://pointclouds.org/documentation/tutorials/greedy_projection.html" rel="nofollow noreferrer">PCL</a>, if only because their documentation has excellent references which should give you ideas on where to look in the literature if you need to roll your own.</p>
<p><a href="https://people.eecs.berkeley.edu/%7Ejrs/" rel="nofollow noreferrer">Jonathan Shewchuk</a> also has some more 2.5D-ish algorithms that may suit your needs.</p>

CC BY-SA 4.0
2021-05-06T01:09:35.560Z
2021-05-06T01:14:43.213Z
2021-05-06T01:14:43.213Z
Pseudonym
<p>Depending on your application, you could use image-based solutions that are much cheaper than meshing a uniformly sampled set of points. For example, you could use the depth map as a <a href="https://en.wikipedia.org/wiki/Heightmap" rel="nofollow noreferrer">height map</a>.</p>

<p>There are many techniques that allow you to render it in an efficient way, the more realistic the more difficult to code as a shader (but not too much). From easiest to harder:</p>

<ul>
<li><a href="https://en.wikipedia.org/wiki/Heightmap" rel="nofollow noreferrer">height maps</a></li>
<li><a href="https://en.wikipedia.org/wiki/Normal_mapping" rel="nofollow noreferrer">normal maps</a></li>
<li><a href="https://en.wikipedia.org/wiki/Displacement_mapping" rel="nofollow noreferrer">displacement mapping</a></li>
<li><a href="https://en.wikipedia.org/wiki/Parallax_mapping" rel="nofollow noreferrer">parallax mapping</a></li>
<li>geometry shaders to recreate the actual mesh from a set of primitives and the depth map</li>
<li>and so on. </li>
</ul>

CC BY-SA 4.0
2019-04-11T06:44:49.297Z
I was looking to create something like this https://vimeo.com/125511537. Didn't know how it's done. I kinda assumed the workflow I mentioned in the question and hypothesised that's how it's done.
Ashish Rao M
CC BY-SA 4.0
2019-04-11T10:50:36.550Z
As far as you have the depth map, I guess the shadow in that video is rendered with [shadow mapping](https://en.wikipedia.org/wiki/Shadow_mapping). The main object may be rendered in many ways. 
The easiest technique (if scanner resolution is not too high) consist on generate a quad per pixel in your depth map and set the axis coordinate according to depth values in the vertexes. If you want to do it in a more efficient way or scanner resolution may vary with time, the quads can be generated by a geometry shader from a more basic mesh.
David
CC BY-SA 4.0
2019-04-11T06:32:48.300Z
2019-04-11T06:32:48.300Z
David
<p>Suppose I have code to generate a bunch of frames, each of which is a depth map(I have access to the matrices which represent depth) which in turn is used to generate a point cloud. One frame would look like this:</p>

<p><a href="https://i.sstatic.net/mo5TN.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/mo5TN.png" alt="enter image description here"></a></p>

<p>In short I have a point cloud corresponding to each frame. How would I generate a video where each point cloud in a frame is meshed together? </p>

<p>Are there frameworks which handle this kind of data? I am assuming OpenGL should help but I am not sure if it can do this.</p>

CC BY-SA 4.0
2020-09-12T09:22:34.710Z
http://wisionlab.cs.wisc.edu/project/quanta-burst-photography/ - maybe this paper will be helpful ("Quanta Burst Photography" by Ma et al. 2020)
DirectX_Programmer
<3d><mesh><video>
Rendering 3-D point clouds obtained from depth maps as a 2.5D video
Ashish Rao M
# Rendering 3-D point clouds obtained from depth maps as a 2.5D video

(Asked by: username_0 on 2019-04-11)

Suppose I have code to generate a bunch of frames, each of which is a depth map(I have access to the matrices which represent depth) which in turn is used to generate a point cloud. One frame would look like this:

[![enter image description here](https://i.sstatic.net/mo5TN.png)](https://i.sstatic.net/mo5TN.png)

In short I have a point cloud corresponding to each frame. How would I generate a video where each point cloud in a frame is meshed together?

Are there frameworks which handle this kind of data? I am assuming OpenGL should help but I am not sure if it can do this.

**Tags:** 3d, mesh, video

> **Comments:**
> **username_1**: http://wisionlab.cs.wisc.edu/project/quanta-burst-photography/ - maybe this paper will be helpful ("Quanta Burst Photography" by Ma et al. 2020)  

---

## 2 answers

### Answer by username_2 on 2021-05-06. Score: 1

There are plenty of algorithms for generating meshes from point clouds. I am going to suggest looking at the libraries [CGAL](https://doc.cgal.org/latest/Manual/tuto_reconstruction.html) and [PCL](https://pointclouds.org/documentation/tutorials/greedy_projection.html), if only because their documentation has excellent references which should give you ideas on where to look in the literature if you need to roll your own.

[Jonathan Shewchuk](https://people.eecs.berkeley.edu/%7Ejrs/) also has some more 2.5D-ish algorithms that may suit your needs.


---

### Answer by username_3 on 2019-04-11. Score: 1

Depending on your application, you could use image-based solutions that are much cheaper than meshing a uniformly sampled set of points. For example, you could use the depth map as a [height map](https://en.wikipedia.org/wiki/Heightmap).

There are many techniques that allow you to render it in an efficient way, the more realistic the more difficult to code as a shader (but not too much). From easiest to harder:

* [height maps](https://en.wikipedia.org/wiki/Heightmap)
* [normal maps](https://en.wikipedia.org/wiki/Normal_mapping)
* [displacement mapping](https://en.wikipedia.org/wiki/Displacement_mapping)
* [parallax mapping](https://en.wikipedia.org/wiki/Parallax_mapping)
* geometry shaders to recreate the actual mesh from a set of primitives and the depth map
* and so on.

> **Comments:**
> **username_0**: I was looking to create something like this https://vimeo.com/125511537. Didn't know how it's done. I kinda assumed the workflow I mentioned in the question and hypothesised that's how it's done.  
> **username_3**: As far as you have the depth map, I guess the shadow in that video is rendered with [shadow mapping](https://en.wikipedia.org/wiki/Shadow_mapping). The main object may be rendered in many ways.  The easiest technique (if scanner resolution is not too high) consist on generate a quad per pixel in your depth map and set the axis coordinate according to depth values in the vertexes. If you want to do it in a more efficient way or scanner resolution may vary with time, the quads can be generated by a geometry shader from a more basic mesh.  

---

