CGAL users discussion list

[omar rodriguez <>]

Hello all,

I am using the Surface Reconstruction from Point Sets component from
CGAL-3.5-beta1 and I would like to know if it is possible to get the
same result after running the program several times using the same
data set.

Any help would be greatly appreciated.

Below are the details:

To estimate the surface normals I am using the Point Set
Processing component without simplifying the point set
(CGAL::grid_simplify_point_set), removing
outliers(CGAL::remove_outliers) or smoothing
(CGAL::jet_smooth_point_set). The example that comes with
CGAL-3.5-beta1 shows this behaviour (
examples/Surface_reconstruction_points_3/poisson_reconstruction.cpp )


My interest in this is to get temporal coherence to use the results in
an animation.

So far I've tried modifying the file
"CGAL/Surface_mesher/Implicit_surface_oracle_3.h" like it was
previously suggested for a similar issue (
https://lists-sop.inria.fr/sympa/arc/cgal-discuss/2008-09/msg00112.html
) with no success.

I've also tried to sorting the way the finite vertices are accessed in
the solve_poisson method defined in the file
"CGAL/Poisson_reconstruction_function.h" but my program fails on the
Choleschy factorization whenever I modified the order of the vertices.

My modifications to "CGAL/Poisson_reconstruction_function.h" are as follow


////////


   std::vector<Vertex_handle> sorted_vertices;

   for(Finite_vertices_iterator v = m_tr->finite_vertices_begin();
           v != m_tr->finite_vertices_end();
           v++)
   {
               if(!v->constrained())
               {
                       sorted_vertices.push_back(v);
               }

       }


       std::sort(sorted_vertices.begin(), sorted_vertices.end(),
orderingObject);

       for (typename std::vector<Vertex_handle>::iterator sortedIterator =
sorted_vertices.begin();
                sortedIterator != sorted_vertices.end();
                ++sortedIterator)
       {
               B[(*sortedIterator)->index()] =
div_normalized(*sortedIterator); //
rhs -> divergent
               assemble_poisson_row(solver,*sortedIterator,B,lambda);

       }
////////

where orderingObject defined on the same class as follows:

struct myVertexOrderingClass {
    bool operator() (Vertex_handle i,Vertex_handle j) { return
(i->point()<j->point());}
} orderingObject;

////////


Cheers,

-- 
Omar

+