Documents
Resources
Learning Center
Upload
Plans & pricing Sign in
Sign Out

ht

VIEWS: 0 PAGES: 49

									Computing handles and tunnels
        in 3D models

                               Tamal K. Dey

        Joint work: Kuiyu Li, Jian Sun, D. Cohen-Steiner



Department of Computer Science and Engineering
          Projects in Jyamiti group
• Surface reconstrucion (Cocone)
• Delaunay meshing (DelPSC)
• Shape feature processing (Segmatch, Cskel)




Department of Computer Science and Engineering
                                                 2/52
       Handle loops/Tunnel loops




Department of Computer Science and Engineering
                                                 3/52
       Handle loops/Tunnel loops




Department of Computer Science and Engineering
                                                 4/52
         Topological Simplification




Department of Computer Science and Engineering
                                                 5/52
     Use of Handles and Tunnels
• Topological simplification / feature recognition /
  parameterization
    • El-Sana and Varshney[1997] use α-hulls to search for tunnels.
    • Guskov and Wood[2001] propose a surface growing strategy
      to remove small handles.
    • Nooruddin and Turk[2003] use morphological operations to
      remove small handles.
    • Wood, Hoppe, Desbrun, and Schroder[2004] use Reeb graph
      to remove handles.
    • Shattuck and Leahy[2001] use Reeb graph to compute
      handles.
    • From WUSTL Model/surface editing (Zhou, Ju, and Hu[2007]
      use medial axis to detect loops) and work by Grimm et al.
Department of Computer Science and Engineering
                                                                 6/52
       Nontrivial loops as first attempt?
•    Nontrivial loops can neither be handle nor tunnel.
•    Handle and tunnel loops have to be non-
     separating.




    Department of Computer Science and Engineering
                                                          7/52
  Related work for loops on surface
• Loops on a surface
    • Compute polygon schemas                     [Vegter-Yap90][Dey-Schipper95]
         • Linear time algorithm
    • Compute optimal systems of loops                     [VL05][EW06]
         • Verdiere and Lazarus gave an algorithm for computing a system
           of loops which is shortest among the homotopy class of a given
           one.
         • Erickson and Whittlesey gave a greedy algorithm to compute the
           shortest system of loops among all systems of loops.
    • Compute optimal cut graph                   [EH04]
         • Computing a shortest cut graph is NP-hard.



 Department of Computer Science and Engineering
                                                                                   8/52
                            A better idea
• Intuitively, a loop on a
  connected, closed, surface M
  in R3 is:
    • handle if it spans a disk
      (surface) in the bounded space
      bordered by M.
    • tunnel if it spans a disk (surface)
      in the unbounded space
      bordered by M.



Department of Computer Science and Engineering
                                                 9/52
    Cycle, Boundary and Homology
• p-chain: c=aii, i is p-simplex.
(e2+e3+e4) is a 1-chain.
• If c'=ai'i, then c+c'=(ai+ai')i.
• c + c = 0 for Z2 coefficients.
• Boundary operator
    • p = [v0,v1,…,vp] = i=0p[v0,…,~vi,…,vp]
    • e.g.: t = (e2+e3+e4)
    • e.g.: e0+ e1+ e4 = (v0+v2)+(v0+v1)+(v1+v2) = 0



Department of Computer Science and Engineering
                                                          10/52
    Cycle, Boundary and Homology
• p-cycle: if pc = 0.
• p-boundary: if there’s (p+1)-chain
  d, s.t. c=pd .
• p-cycle group Zp = kernel (p).
• p-boundary group Bp = image (p+1).
• Hp= Zp / Bp
    • Each element of Hp represents an equivalent class.
    • c1 and c2 are in the same class if c1 + c2 is in Bp.
    • Trivial elements in Hp bounds (p+1)-chain



Department of Computer Science and Engineering
                                                             11/52
           Handle and tunnel loops                                 –
                             definitions         [Dey-Li-Sun 07]


• Let M be a connected, closed,
  surface in R3. M separates R3 into
  inside I and outside O. Both I and O
  have M as boundary.
• Handle: A loop on M whose
  homology class is trivial in H1(I) and
  non-trivial in H1(O).
• Tunnel: A loop on M whose
  homology class is trivial in H1(O)
  and non-trivial in H1(I).

Department of Computer Science and Engineering
                                                                       16/52
                                    Nasty knots
•    Consider a thickened trefoil
      • handle loop (green)

      • tunnel loop (red)




    Department of Computer Science and Engineering
                                                     17/52
        Handle and tunnel loops                   –
                                      existence

• Theorem (Dey, Li, Sun[2007])
    • For any connected closed surface M of genus
      g in R3, there exist g handle loops {hi}i=1…g
      forming a basis for H1(O) and g tunnel loops
      {ti}i=1...g forming a basis for H1(I).

    • Furthermore, {hi}i=1...g and {ti}i=1...g form a
      basis for H1(M).



Department of Computer Science and Engineering
                                                        18/52
       First algorithm for GR models
                                            [Dey-Li-Sun 07]



•     Graph retractability assumption : A surface is
      graph retractable if both I and O deformation
      retract to a graph, denoted I and O, respectively.




    Department of Computer Science and Engineering
                                                              19/52
                Inner and outer cores
• I and O are disjoint core graphs, each with g loops
  : {KjI}j=1g and {KjO}j=1g and {Kj}j=12g all together.




• How to compute I and O ?
 Department of Computer Science and Engineering
                                                      20/52
                        Linking number
• J and K are two disjoint loops in R3.
• In a regular projection, there are two ways in
  which J crosses under K.
• The linking number, lk(K, J), is the sum of these
  signed crossings.




Department of Computer Science and Engineering
                                                      21/52
           Linking number Theorem
• A loop  on M is a handle iff lk(, KiI)  0 for at least
  one inner core and lk(, KiO)=0 for all outer cores.
• A loop  on M is a tunnel iff lk(, KiO)  0 for at least
  one outer core and lk(, KiI)=0 for all inner cores.




 Department of Computer Science and Engineering
                                                              22/52
                     Minimally linked basis
• A loop is minimally linked if it links once only with one core loop.
• Theorem : There exist 2g minimally linked loops, denoted {Jj}j=12g, such
  that lk(Ki, Jj)=ij.
• Half of them linked with KiI’s, denoted {JjI}j=1g, are handle loops.
• Other half linked with KiO’s, denoted {JjO}j=1g, are tunnel loops.
• {[JjI]} j=1g form a basis for H1(I) and {[JjO]}j=1g form a basis for H1(O).
  Hence {[Jj]}j=12g form a basis for H1(M).




   Department of Computer Science and Engineering
                                                                            23/52
                 Topological algorithm
• Assume I and O are given.
• Step1: Compute {Ki}i=12g using the spanning tree of I and O.
• Step2: Compute a system of 2g loops on M, denoted {j}j=12g.
  (say by Dey-Schipper or Vegter-Yap linear time algorithms)
• Step3: Compute lk(Ki, j) for all i and j. Let A be the 2gx2g
  matrix {lk(Ki, j)}.
    • A is the transform matrix from a minimally linked basis {[Jj]}j=12g to
      basis {[j]} j=12g.
    • A-1 = {aji} exists and has integer entries.
    • [Jj] = i=12g aji[i].
• Step4: Obtain Jj by concatenating i’s according to the above
  expression.

  Department of Computer Science and Engineering
                                                                               24/52
  An implementation to compute system of
   handle and tunnel loops with small size
• Compute I and O
    • Basic idea: Collapse the inside (outside)
      Voronoi diagram to obtain I (O).
    • The curve-skeleton [Dey-Sun06]
      captures the geometry better.
         • Each skeleton edge (e) gets associated
           with an additional value called geodesic
           size (g(e)) indicating the local size of M.
         • Establish graph structure on the curve
           skeleton.
         • The geodesic size for a graph edge, g(E)
           = min{g(e): e is a skeleton edge in E}.

    • Issue: not always work for any graph
      retractable surface, e.g., a thickening of
      a house with two room.
Department of Computer Science and Engineering
                                                         25/52
  Core graphs by curve-skeletons[DS05]




Department of Computer Science and Engineering
                                                 26/52
  An implementation to compute system of
   handle and tunnel loops with small size

• Compute core loops {Kj}j=12g
    • Compute the maximal spanning tree for I and O
      using geodesic sizes as weight.
    • Add the remaining edges, Ei’s, to form Ki’s.
• Compute minimally linked {Jj}j=12g
    • Basic idea: compute Ji’s at different location
      indicated by Ei’s.
    • Let e be the skeleton edge with the smallest
      geodesic size in Ei. Let p be one of the vertices
      of the dual Delaunay triangle of e.
    • Compute an optimal system of loops by geodesic
      exploration and apply topological algorithm.
         • In our experiments, one of the loop in the system
           of loops itself satisfies the condition to be Ji’s.

Department of Computer Science and Engineering
                                                                 27/52
                                      Results




Department of Computer Science and Engineering
                                                 28/52
  A Persistence based algorithm
                             [Dey-Li-Sun-Cohen-Steiner 08]


• A fast algorithm based on persistent homology
  introduced by Edelsbrunner, Letscher,
  Zomorodian[2002].
• The algorithm does not require any extra
  structure such as medial axis, curve skeleton, or
  Reeb graphs.
• It works on a larger class of models. Both
  surface mesh and isosurface with volume grids
  can be input.


Department of Computer Science and Engineering
                                                             29/52
   Filtration in persistent homology
• Filtration of a simplicial complex K is a nested
  sequence of complexes:
   • 0 = K-1 < K0 < K1 < …< Kn = K
   • Assume Ki - Ki-1 = i
• Persistence homology studies how the homology
  groups change over the filtration.
• In our algorithm, we use the pairing concept in
  the persistent homology.


Department of Computer Science and Engineering
                                                     30/52
     Positive and Negative simplices
• Once a p-simplex  is added to Ki-1, it is
    • Positive if it creates a non-boundary p-cycle.
    • Negative if it kills an existing (p-1)-cycle.
• A negative p-simplex  is always paired with a
  unique positive (p-1)-simplex ' where  kills
  a (p-1)-cycle created by '.




Department of Computer Science and Engineering
                                                       31/52
  Positive and negative simplices




Department of Computer Science and Engineering
                                                 32/52
        Pairing algorithm                        – pair ()
1) c=p
2) d is youngest positive (p-1)-simplex in c
3) while (d is paired and c  Φ) do
    • Let c' be the cycle killed by the simplex paired with d
    • c=c'+c
    • d is the youngest positive (p-1)-simplex in c
   end while
4) if c is not empty, then
          is negative p-simplex and paired with d
    else
          is positive p-simplex.
Department of Computer Science and Engineering
                                                                33/52
 Computing handle and tunnel loops
• Topological algorithm
• Two refinements for improving loop quality.
• Assume M, I, and O denote the simplicial
  complexes of surface, inside, and outside
  respectively; g is the genus of M.




Department of Computer Science and Engineering
                                                 35/52
               Topological algorithm
• 3 Steps:
    • 1) Simplices of M are added to the filtration, generating
      2g unpaired positive edges;
    • 2) Simplices of I are added, g previously unpaired
      edges get paired, each pair corresponds to a handle
      loop;
    • 3) Simplices of O are added, the rest of g unpaired
      edges get paired, each pair corresponds to a tunnel
      loop.



Department of Computer Science and Engineering
                                                              36/52
         Topological algorithm                   cont.




Department of Computer Science and Engineering
                                                         37/52
                            Refinement 1
• For a negative triangle , a
  series of homologous loops
  are obtained.
• Let L1, L2,…,Lk be those
  that lie on M, sorted by the
  time when they are found.
  Set the handle (or tunnel)
  loop L() for  as L1.



Department of Computer Science and Engineering
                                                 38/52
                            Refinement 2
• A handle (or tunnel) loop
  is found when a cross
  section of M get filled.
• Cross sections of small size
  will get filled first if we add
  triangles in I and O to the
  filtration in increasing
  order of their geodesic
  sizes.


Department of Computer Science and Engineering
                                                 39/52
         Computing geodesics – for
                                   refinement 2

• Geodesic size of an edge E
  =(A1, A2): geodesic distance
  between points A1' and A2' on M,
  where Ai'=Ai if Ai is on M;
  otherwise, Ai' is the closet point
  on M for Ai
• Geodesic size size of a
  triangle t: max {g(e)|e is in t}



Department of Computer Science and Engineering
                                                  40/52
                        Entire algorithm
• 1) Compute geodesic size for edges and triangles in
  I and O;
• 2) For each simplex  on M, pair();
• 3) E = unpaired positive edges on M;
• 4) In the order of increasing geodesic size, pair()
  for each triangle  in I;
• 5) if ( is negative and its paired positive edge is in
  E), then output a handle: hi = L();
• 6) Do similarly as 4) and 5) to get tunnels.

Department of Computer Science and Engineering
                                                       41/52
                        Entire algorithm




Department of Computer Science and Engineering
                                                 42/52
                  Gearbox (genus 78)




Department of Computer Science and Engineering
                                                 43/52
         Isosurface Fuel (genus 8)




Department of Computer Science and Engineering
                                                 44/52
  Isosurface (Engine, genus 20)




Department of Computer Science and Engineering
                                                 45/52
                                 Aneurysm




Department of Computer Science and Engineering
                                                 46/52
                Knotty cup and noise




Department of Computer Science and Engineering
                                                 47/52
                             Experiments
• We implemented our algorithm in C++. All
  experiments were done on a Dell PC with 2.8GHz
  Intel Pentium D CPU and 1GB RAM.




Department of Computer Science and Engineering
                                                   48/52
                     Feature Detection
• Compute handle (tunnel)
  features based on handle
  (tunnel) loops.
    • Sweep the handle (tunnel) loop
      until the length become too long.




Department of Computer Science and Engineering
                                                 49/52
          Topological simplification




Department of Computer Science and Engineering
                                                 50/52
            Simplification (Buddha)




Department of Computer Science and Engineering
                                                 51/52
        Conclusions and future work
•    A simple, topologically correct algorithm for handles
     and tunnels.
•    Mathematical proof of geometric qualities of the loops?
•    What about surfaces with boundaries?
•    Handletunnel software available from
    http://www.cse.ohio-state.edu/~tamaldey/handle.html




    Department of Computer Science and Engineering
                                                           52/52
                    Pegasus (genus 5)




Department of Computer Science and Engineering
                                                 53/52
                     2-torus (genus 2)




Department of Computer Science and Engineering
                                                 54/52

								
To top