Mapping Three Dimensional Objects from a Sequence of Two 

Dimensional Images 
-- Midterm Report -- 
 
Wednesday, March 27th, 2019 
 
Justin Essert Aabhas Singh 
essert@wisc.edu singh36@wisc.edu 
Department of Electrical and Computer Engineering  Department of Engineering Physics 
 
Elliott Janssen Saldivar Benjamin Moldenhauer 
ejanssensald@wisc.edu bmoldenhauer@wisc.edu 
Department of Computer Sciences Department of Engineering Physics 
 
 
 
1.0 Introduction 
 
The  goal  of  this  project  is  to  develop  a  photogrammetry  process  that  will  allow  for 
efficient  generation  of  a  3D  printable  model  of  an  arbitrary  object  from  a  sequence  of 
images.  This  will  be  done  by  first  using  VisualSFM  to  generate  a  3D  point  cloud  based  on a 
video  taken  of  a  slowly revolving object. The point cloud can then be imported into MATLAB, 
where  extraneous  points  of  the  surrounding  environment  must  be  manually  removed.  This 
will  produce  a  digital  representation  of  the  object,  in  the  form  of  3D  points  on  its  surface.  A 
denoising  operation is then implemented to smooth the point cloud of erroneous data points, 
after  which  a  segmentation  process  will  cluster  similar  points  and  produce  a  representative 
point  characterizing  that  section  of  surface geometry. This simplified point cloud can then be 
used  to  generate  a  triangularized  mesh  that  roughly  captures  the surface geometry. A mesh 
refinement  step  can  then  be  implemented  that  creates  subdivisions  of  the  triangulation  that 
are  projected  to  more  closely  represent  the  object  surface  geometry.  The  point  cloud  and 
mesh  should  then  be  of  sufficient  quality  to  produce  a  viable  3D  print.  Existing  commercial 
products can do this, but open source options are lacking.  
This  process  is largely adapted from the work done in [1], in which the authors present 
a  framework  for  smoothing  a  point  cloud  and  generating  an  accurate  mesh.  The  present 
work  will  build  upon  these  ideas  and  adapts  them  to  the  goal  of  producing  a  3D  printable 
model.  The  following  sections  provide  details  on  what  work  has  been  done  toward 
completing these goals, and what is still to be accomplished. 
 
 
 
2.0 Progress Made 
a. Generating a Point Cloud 
To  kick  off  our project, we started by trying to determine an easy object that we could 
generate a point cloud from. After some deliberation, we decided to use a Rubik's cube since 
it’s  different  colored  faces  would  make  it  easier  for  a  point  cloud  generation  algorithm  to 
distinguish each face.  
 

 
   
Figure 1: Original Rubik's Cube  Figure 2: Point Cloud - First Attempt  Figure 3: Point Cloud - Second Attempt 

 
We  started  working  on  our  project  by  creating  a  360  degree  video  of  the  Rubik's 
cube  and  then  using  MATLAB  to  divide each frame into a different jpg file [Figure 1 shows an 
example  frame  of  the  video].  Once  the  video  frames  were  divided  into  separate jpg images, 
we  loaded  all  of  the  images  into  VisualSFM  to  create  a  point  cloud  [Figure  2  shows  our first 
attempt at a point cloud].  
The  first  point  cloud  we  created  was  surprisingly  low  quality,  it  had  a  very  significant 
amount  of  noise  around  the  cube  and  was  missing  a  full  face  of  the  cube.  This  was  the 
biggest  difficulty  that  we’ve  run  into  so  far  in  the  project,  since  the  quality  of  the  first  point 
cloud was so bad, we were not able to just remove the noise.  
Ultimately,  we  ended  up  trying  to  understand  the  process  that  VisualSFM  was  going 
through  better  and  ultimately  figured  out  that,  although  we  had  taken  the  video  in a smooth 
circle  around  the  rubik's  cube,  the  images  were  being  stitched  together  in  a  non-circular 
pattern.  Once  we  noticed  that,  we  decided  to  take  a  new  video  where  we  were  set  up  a 
spinning  surface  to  put  the  rubik's  cube  on  and  we  were  much  more  meticulous  about 
ensuring  that  there  was  no  background  noise  in  the  video.  Upon again converting the video 
to  images  and  running  it  through  VisualSFM  again,  we  were  rewarded  with  a  much  better 
result [Figure 3 shows our second attempt at generating a point cloud]. 
 
 
 
 
 
 b. Denoising The Point Cloud 
Since  our  generated  point  cloud  had  points  for  the  surface  that  the  rubik's  cube  was 
on  as well as some obvious noisy points around the cube, our next step was to remove those 
points.  To  do  this,  we imported our point cloud into MeshLab and did some quick clean up of 
unnecessary points. 

   
Figure 4: Noisy Point Cloud in MeshLab  Figure 5: Cleaned Point Cloud in MeshLab 

 
The  process  of  removing  obvious  noisy  points  from  our  point cloud successfully took 
our  noisy  cloud  [Figure  4  shows  our  noisy  cloud  in  MeshLab]  to  a  much  cleaner  point  cloud 
containing  only  the  relevant  cube  [Figure  5  shows  our  cleaned cloud in Meshlab].  Once this 
was  done,  the  next  step  is  to  implement  the  algorithmic  smoothing  of  our  point  cloud  that 
cleans  our  point  cloud  further  and  makes  it  easier  to  achieve  a  quality  result  from  the 
following sections.  
This  step  of  smoothing  is  the  first  where  we begin to follow the process outlined in [1] 
and  is  described  in  more  detail  in  [2,3].  We  are  currently  in  the  process of implementing this 
smoothing,  but  have  not  successfully  completed  the  algorithm  to  the  point  where  we  could 
show  results.  Since  we  don’t  yet  have  results  to  show  here,  we  will  instead  briefly  describe 
the process that we are following. 
The  smoothing  algorithm  that we are implementing has the goal of transforming noisy 
point  cloud,  P,  which  is  close  to  some  unknown  surface  S,  into  a  noise-free  dataset 
P ′ = {r′ = Q(r) : r ∈ P }   where  r  is  a  noisy  point,  r’  is  the  corresponding  noise-free  point, 
and  Q(r) is a smoothing operator. The smoothing operator is defined as  Q(r) = r + tr nr where 
n​r  is  the  projection  direction  and  t​r  is  the  displacement.  The  optimal  values  of  t​r  and  n​r  are 
found  through  an  optimization  described  in  depth  in  [2] but we will skip over it in the interest 
of  time  and  space.  Overall,  this  smoothing  algorithm  can  be  interpreted  as  an  extension  of 
the  common  moving  least  squares  method  which  preserves  the  underlying  features  of  the 
input point cloud. 
3.0 Brief Plan for Future Work 
a. Clustering 
The  goal  of  clustering  is  to  create  a  finite  set  of  groups  containing  similarly  planar 
points.  This  can  be  achieved  using  a  hierarchical  approach  of  a  binary  space  partitioning 
(BSP)  tree,  which  in  our  case  involves  recursively  dividing  the  surface  into  two  until  the 
subset  of  surface  points  satisfies  several  criteria  [4].  These  criteria  include  flatness  of  the 
point set and a minimum number of points required for each cluster.  
 
b. Reduction 
The  goal  of  reduction  is  to  find  a  small  set  of  points  to  represent  the  surface  of  the 
object.  To  do  this,  we  can  take  the  centroid  of  the  cluster  and  project  that  closer  to  the 
surface, given that this point may not lie exactly on the surface [1]. 
 
c. Triangulation 
The  goal  of  this  step  is  to  triangulate  a  surface  using the points found in the previous 
step,  roughly  approximating  the  actual  surface  for  later  refinement.  The  incremental 
algorithm  is  based  on  k-nearest  neighbors,  similar  to  what  other  greedy  algorithms  use.  In 
each  iteration  to  expand  the  surface  border,  we  can  take  a  border  edge  and  find  a 
corresponding  point  to  complete  the  triangle  using  several  heuristics,  including  angle, 
collinearity,  and  distance  [1].  An  example  of  this  is  shown  below  through  MeshLab.  The  left 
image  shows  delaunay triangulation without clustering. This connects lines to all points in the 
point  cloud.  The  image  on  the  right  clusters  the  points  within  a  given radius and repeats the 
triangulation.  
 

 
Figure 6: Delaunay triangulation without clustering  Figure 7: Delaunay triangulation with clustering 
  
d. Refinement 
To  refine  the  triangularized  mesh,  subdivisions  of  each  line  are created if the mesh is 
determined  to  insufficiently  capture  the  shape  of  the  point  cloud  surface.  This  is  done 
iteratively,  line  by  line,  where the original point cloud is compared to the mesh line, and if the 
line  is  found  to  deviate  from the object points, a new midside point is created on the line and 
translated  toward  the  point  cloud.  A  new  pair  of  triangles  is  then  defined  between  the 
existing  mesh  coordinates  and  the  newly  generated  point. The process is complete when all 
mesh lines have been found to capture the point cloud geometry, or have been divided to do 
so.  
 
4.0 References 
1. Mederos, Boris, Velho, Luiz, and Henrique De Figueiredo, Luiz, “Smooth Surface 
Reconstruction from Noisy Clouds,” ​ResearchGate​. [Online]. Available: 
https://www.researchgate.net/publication/2887809_Smooth_Surface_Reconstruction
_from_Noisy_Clouds. [Accessed: 26-Mar-2019]. 
2. Mederos, Boris, Velho, Luiz, and Henrique De Figueiredo, Luiz, “Robust smoothing of 
noisy point clouds,” ​ResearchGate​. [Online]. Available: 
https://www.researchgate.net/publication/228816101_Robust_smoothing_of_noisy_p
oint_clouds. [Accessed: 26-Mar-2019]. 
3. Mederos, Boris, Velho, Luiz, and Henrique De Figueiredo, Luiz, “Surface Reconstruction
and Smoothing from Point Clouds,” ​ResearchGate​. [Online]. Available:
https://www.researchgate.net/publication/265635083_Surface_Reconstruction_and_S
moothing_from_Point_Clouds. [Accessed: 26-Mar-2019].
4. “Binary Space Partitions.” [Online]. Available:
http://groups.csail.mit.edu/graphics/classes/6.838/S98/meetings/m13/bsp.html.
[Accessed: 27-Mar-2019].