CGAL users discussion list

[Nader SALMAN <>]

Dear Tina,

sorry for the little late reply, i just corrected the lack of Property_maps compatibility in our code,
and corrected a small bug in your example code. It works now :-)
So please try it and let me know. You will find attached to this mail the corrected versions of
grid_simplify_point_set.h as well as grid_simplification_example.cpp (just replace the old files
with the new ones)

Thanks again!

Yours,
Nad.

Nader SALMAN
Geometrica Lab, Byron Y308
INRIA Sophia Antipolis (FRANCE)

Tel: +33(0)4 9238 7161   Fax: +33(0)4 9715 5395   


http://www-sop.inria.fr/members/Nader.Salman

tina rumi a écrit :

Thank you Nader!

On Thu, Dec 10, 2009 at 12:37 PM, Nader SALMAN <> wrote:

Dear Tina,

Laurent and i discussed your issue and we think that the problem is in
the code of grid_simplify_point_set.h. We are really thankful that you
pointed that out and we are currently working on the bug. We will
keep you informed as soon as the bug is corrected.

Best regards,
NadR

Nader SALMAN
Geometrica Lab, Byron Y308
INRIA Sophia Antipolis (FRANCE)

Tel: +33(0)4 9238 7161   Fax: +33(0)4 9715 5395   


http://www-sop.inria.fr/members/Nader.Salman

tina rumi a écrit :

Thanks Nader and Laurent,

actually, it didn't work again. my data doesn't include normal , so I have to read just x,y and z then produce the normal with cgal function. I am using vector for the data type also , I put the list in the comment , so I don't think bug is related to that. I will copy my code here again. I copy my code here, I really appriciate if you can help me. I test my code part by part and the problem is in the simplification part.
Nader, we define FT in the code but never use it, do we need it here?



#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/property_map.h>
#include <CGAL/remove_outliers.h>
#include <CGAL/IO/read_xyz_points.h>
#include <CGAL/grid_simplify_point_set.h>
#include <CGAL/jet_smooth_point_set.h>
#include <CGAL/pca_estimate_normals.h>
#include <CGAL/mst_orient_normals.h>
#include <CGAL/property_map.h>
#include <CGAL/IO/write_xyz_points.h>

#include <vector>
#include <fstream>
#include <utility> // defines std::pair
#include <list>

// types

// kernel
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;

// Simple geometric types
typedef Kernel::FT FT;
typedef Kernel::Point_3 Point;
typedef Kernel::Vector_3 Vector;

// Point with normal vector stored in a std::pair.
typedef std::pair<Point, Vector> PointVectorPair;
typedef std::vector<PointVectorPair> PointList;

int main(void)
{

  PointList points; // Type of input point set

  // Reads a .xyz point set file in points[].
  // The Dereference_property_map property map can be omitted here as it is the default value.
  //std::list<PointVectorPair> points;

  std::ifstream stream("../data/sphere.xyz");
  if (!stream ||
      !CGAL::read_xyz_points(stream, std::back_inserter(points),
                             CGAL::First_of_pair_property_map<PointVectorPair>()
                             ))
  {
    std::cerr << "Error: cannot read file data" << std::endl;
    return EXIT_FAILURE;
  }

  // Removes outliers using erase-remove idiom.
  // The Dereference_property_map property map can be omitted here as it is the default value.
  const double removed_percentage = 5.0; // percentage of points to remove
  const int nb_neighbors = 24; // considers 24 nearest neighbor points
  points.erase(CGAL::remove_outliers(points.begin(), points.end(),
                                     CGAL::Dereference_property_map<Point>(),
                                     nb_neighbors, removed_percentage),
               points.end());

 
   // Optional: after erase(), use Scott Meyer's "swap trick" to trim excess capacity
    PointList(points).swap(points);

     
    // simplification by clustering using erase-remove idiom
     double cell_size = 0.001;
     PointList::iterator unwanted_points_begin = CGAL::grid_simplify_point_set(points.begin(), points.end(), CGAL::First_of_pair_property_map<PointVectorPair>(), cell_size);

    // delete unwanted points
     points.erase(unwanted_points_begin , points.end());

   // Optional: after erase(), use Scott Meyer's "swap trick" to trim excess capacity
    PointList(points).swap(points);



 
  // Smoothing.
  const unsigned int nb_neighbors2 = 8; // default is 24 for real-life point sets
  CGAL::jet_smooth_point_set(points.begin(), points.end(), CGAL::First_of_pair_property_map<PointVectorPair>(), nb_neighbors2);

  // Estimates normals direction.
  // Note: pca_estimate_normals() requires an iterator over points
  // as well as property maps to access each point's position and normal.
  const int nb_neighbors3 = 18; // K-nearest neighbors = 3 rings
  CGAL::pca_estimate_normals(points.begin(), points.end(),
                               CGAL::First_of_pair_property_map<PointVectorPair>(),
                               CGAL::Second_of_pair_property_map<PointVectorPair>(),
                               nb_neighbors3);

   
    // Orients normals.
    // Note: mst_orient_normals() requires an iterator over points
    // as well as property maps to access each point's position and normal.
    PointList::iterator unoriented_points_begin =
    CGAL::mst_orient_normals(points.begin(), points.end(),
                                 CGAL::First_of_pair_property_map<PointVectorPair>(),
                                 CGAL::Second_of_pair_property_map<PointVectorPair>(),
                                 nb_neighbors);

    // Optional: delete points with an unoriented normal
    // if you plan to call a reconstruction algorithm that expects oriented normals.
    points.erase(unoriented_points_begin, points.end());

    // Optional: after erase(), use Scott Meyer's "swap trick" to trim excess capacity
    PointList(points).swap(points);

// Saves point set.
    // Note: write_xyz_points_and_normals() requires an output iterator
    // over points as well as property maps to access each
    // point position and normal.
    std::ofstream out("out_normal.xyz");
    if (!out ||
        !CGAL::write_xyz_points_and_normals(
            out, points.begin(), points.end(),
            CGAL::First_of_pair_property_map<PointVectorPair>(),
            CGAL::Second_of_pair_property_map<PointVectorPair>()))
    {
      return EXIT_FAILURE;
    }


  return EXIT_SUCCESS;
}



Thank you,
Tina

On Wed, Dec 9, 2009 at 4:33 AM, Nader Salman <> wrote:

Hi Laurent,

i read Tina's code but culdn't answer yesterday.

Here are the quick remarks:

#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>

#include <CGAL/property_map.h>

#include <CGAL/IO/read_xyz_points.h>

#include <CGAL/grid_simplify_point_set.h>

#include <CGAL/property_map.h>

#include <vector>
#include <fstream>
#include <utility> // defines std::pair

 #include <list> // IMPORTANT : This method modifies the order of input
                         // points so as to pack all remaining points first,
                         // and returns an iterator over the first point to remove
                         // (see erase-remove idiom). For this reason it should not
                         // be called on sorted containers.

// types

// kernel
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;

// Simple geometric types
typedef Kernel::FT FT;
typedef Kernel::Point_3 Point;
typedef Kernel::Vector_3 Vector;

// Point with normal vector stored in a std::pair.
typedef std::pair<Point, Vector> PointVectorPair;
typedef std::vector<PointVectorPair> PointList;

int main(void)

{

    PointList points; // Type of input point set

    // Reads a .xyz point set file in points[].
    // The Dereference_property_map property map can be omitted here as it is the default value.

    Bug std::list<PointVectorPair> points; // Check important notice higher and redefinition here...

        std::ifstream stream("../data/kitten.xyz");
    Bug CGAL::read_xyz_points// if you want to read the normals you should use the correct function
        if (!stream ||
            !CGAL::read_xyz_points_and_normals(stream, std::back_inserter(points),
            CGAL::First_of_pair_property_map<PointVectorPair>(),
            CGAL::Second_of_pair_property_map<PointVectorPair>()))

        {
            std::cerr << "Error: cannot read file data" << std::endl;
            return EXIT_FAILURE;
        }

        // simplification by clustering using erase-remove idiom
        double cell_size = 0.001;
        PointList::iterator unwanted_points_begin =
            CGAL::grid_simplify_point_set(points.begin(), points.end(),
            CGAL::First_of_pair_property_map<PointVectorPair>(), cell_size);

        // delete unwanted points
        points.erase(unwanted_points_begin , points.end());

        // Optional: after erase(), use Scott Meyer's "swap trick" to trim excess capacity
        PointList(points).swap(points);

        // Saves point set.
        // Note: write_xyz_points_and_normals() requires an output iterator
        // over points as well as property maps to access each
        // point position and normal.
        std::ofstream out("out_normal.xyz");
        if (!out ||
            !CGAL::write_xyz_points_and_normals(

            out, points.begin(), points.end(),

            CGAL::First_of_pair_property_map<PointVectorPair>(),

            CGAL::Second_of_pair_property_map<PointVectorPair>()))
        {
            return EXIT_FAILURE;
        }


        return EXIT_SUCCESS;
}

Cheers,
Nader S.

Laurent Saboret a écrit :

Hi Tina,

Could you please post your complete code, so we can try to reproduce the compilation error below.

Best regards,
Laurent Saboret


tina rumi wrote:

Hi Nad,

Thanks a lot for your help. I am getting another error when I am running your code. here is the error that I got:

1>Compiling...
1>cloud_points.cpp
1>c:\cgal\cgal-3.5\include\cgal\grid_simplify_point_set.h(61) : error C2039: 'x' : is not a member of 'std::pair<_Ty1,_Ty2>'
1>        with
1>        [
1>            _Ty1=Point,
1>            _Ty2=Vector
1>        ]
1>        c:\cgal\cgal-3.5\include\cgal\grid_simplify_point_set.h(59) : while compiling class template member function 'bool CGAL::CGALi::Less_epsilon_points_3<Point_3>::operator ()(const Point_3 &,const Point_3 &) const'
1>        with
1>        [
1>            Point_3=Enriched_point
1>        ]
1>        c:\program files (x86)\microsoft visual studio 9.0\vc\include\set(48) : see reference to class template instantiation 'CGAL::CGALi::Less_epsilon_points_3<Point_3>' being compiled
1>        with
1>        [
1>            Point_3=Enriched_point
1>        ]
1>        c:\program files (x86)\microsoft visual studio 9.0\vc\include\xtree(22) : see reference to class template instantiation 'std::_Tset_traits<_Kty,_Pr,_Alloc,_Mfl>' being compiled
1>        with
1>        [
1>            _Kty=Enriched_point,
1>            _Pr=CGAL::CGALi::Less_epsilon_points_3<Enriched_point>,
1>            _Alloc=std::allocator<PointVectorPair>,
1>            _Mfl=false
1>        ]
1>        c:\program files (x86)\microsoft visual studio 9.0\vc\include\xtree(63) : see reference to class template instantiation 'std::_Tree_nod<_Traits>' being compiled
1>        with
1>        [
1>            _Traits=std::_Tset_traits<Enriched_point,CGAL::CGALi::Less_epsilon_points_3<Enriched_point>,std::allocator<PointVectorPair>,false>
1>        ]
1>        c:\program files (x86)\microsoft visual studio 9.0\vc\include\xtree(89) : see reference to class template instantiation 'std::_Tree_ptr<_Traits>' being compiled
1>        with
1>        [
1>            _Traits=std::_Tset_traits<Enriched_point,CGAL::CGALi::Less_epsilon_points_3<Enriched_point>,std::allocator<PointVectorPair>,false>
1>        ]
1>        c:\program files (x86)\microsoft visual studio 9.0\vc\include\xtree(107) : see reference to class template instantiation 'std::_Tree_val<_Traits>' being compiled
1>        with
1>        [
1>            _Traits=std::_Tset_traits<Enriched_point,CGAL::CGALi::Less_epsilon_points_3<Enriched_point>,std::allocator<PointVectorPair>,false>
1>        ]
1>        c:\program files (x86)\microsoft visual studio 9.0\vc\include\set(57) : see reference to class template instantiation 'std::_Tree<_Traits>' being compiled
1>        with
1>        [
1>            _Traits=std::_Tset_traits<Enriched_point,CGAL::CGALi::Less_epsilon_points_3<Enriched_point>,std::allocator<PointVectorPair>,false>
1>        ]
1>        c:\cgal\cgal-3.5\include\cgal\grid_simplify_point_set.h(99) : see reference to class template instantiation 'std::set<_Kty,_Pr>' being compiled
1>        with
1>        [
1>            _Kty=Enriched_point,
1>            _Pr=CGAL::CGALi::Less_epsilon_points_3<Enriched_point>
1>        ]
1>        c:\cgal\cgal-3.5\include\cgal\grid_simplify_point_set.h(154) : see reference to class template instantiation 'CGAL::Epsilon_point_set_3<Point_3>' being compiled
1>        with
1>        [
1>            Point_3=Enriched_point
1>        ]
1>        c:\cgal\cgal-3.5\include\cgal\grid_simplify_point_set.h(190) : see reference to function template instantiation 'ForwardIterator CGAL::grid_simplify_point_set<ForwardIterator,PointPMap,CGAL::Filtered_kernel<CK>>(ForwardIterator,ForwardIterator,PointPMap,double,const Kernel &)' being compiled
1>        with
1>        [
1>            ForwardIterator=std::_Vector_iterator<PointVectorPair,std::allocator<PointVectorPair>>,
1>            PointPMap=CGAL::First_of_pair_property_map<PointVectorPair>,
1>            CK=CGAL::Simple_cartesian<double>,
1>            Kernel=CGAL::Filtered_kernel<CGAL::Simple_cartesian<double>>
1>        ]
1>        f:\fingerprint\codes\cloud_points\cloud_points\cloud_points.cpp(203) : see reference to function template instantiation 'ForwardIterator CGAL::grid_simplify_point_set<std::_Vector_iterator<_Ty,_Alloc>,CGAL::First_of_pair_property_map<Pair>>(ForwardIterator,ForwardIterator,PointPMap,double)' being compiled
1>        with
1>        [
1>            ForwardIterator=std::_Vector_iterator<PointVectorPair,std::allocator<PointVectorPair>>,
1>            _Ty=PointVectorPair,
1>            _Alloc=std::allocator<PointVectorPair>,
1>            Pair=PointVectorPair,
1>            PointPMap=CGAL::First_of_pair_property_map<PointVectorPair>
1>        ]
1>c:\cgal\cgal-3.5\include\cgal\grid_simplify_point_set.h(62) : error C2039: 'y' : is not a member of 'std::pair<_Ty1,_Ty2>'
1>        with
1>        [
1>            _Ty1=Point,
1>            _Ty2=Vector
1>        ]
1>c:\cgal\cgal-3.5\include\cgal\grid_simplify_point_set.h(63) : error C2039: 'z' : is not a member of 'std::pair<_Ty1,_Ty2>'
1>        with
1>        [
1>            _Ty1=Point,
1>            _Ty2=Vector
1>        ]
1>c:\cgal\cgal-3.5\include\cgal\grid_simplify_point_set.h(63) : error C2661: 'std::pair<_Ty1,_Ty2>::pair' : no overloaded function takes 3 arguments
1>        with
1>        [
1>            _Ty1=Point,
1>            _Ty2=Vector
1>        ]
1>c:\cgal\cgal-3.5\include\cgal\grid_simplify_point_set.h(64) : error C2039: 'x' : is not a member of 'std::pair<_Ty1,_Ty2>'
1>        with
1>        [
1>            _Ty1=Point,
1>            _Ty2=Vector
1>        ]
1>c:\cgal\cgal-3.5\include\cgal\grid_simplify_point_set.h(65) : error C2039: 'y' : is not a member of 'std::pair<_Ty1,_Ty2>'
1>        with
1>        [
1>            _Ty1=Point,
1>            _Ty2=Vector
1>        ]
1>c:\cgal\cgal-3.5\include\cgal\grid_simplify_point_set.h(66) : error C2039: 'z' : is not a member of 'std::pair<_Ty1,_Ty2>'
1>        with
1>        [
1>            _Ty1=Point,
1>            _Ty2=Vector
1>        ]
1>c:\cgal\cgal-3.5\include\cgal\grid_simplify_point_set.h(66) : error C2661: 'std::pair<_Ty1,_Ty2>::pair' : no overloaded function takes 3 arguments
1>        with
1>        [
1>            _Ty1=Point,
1>            _Ty2=Vector
1>        ]
1>Build log was saved at "file://f:\fingerprint\codes\cloud_points\cloud_points\Debug\BuildLog.htm"
1>cloud_points - 8 error(s), 0 warning(s)
========== Rebuild All: 0 succeeded, 1 failed, 0 skipped ==========


Thank you,
Tina

On Tue, Dec 8, 2009 at 12:57 PM, Nader SALMAN <> wrote:

A correction , here you go :

// kernel
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;

// Simple geometric types
typedef Kernel::FT FT;
typedef Kernel::Point_3 Point;
typedef Kernel::Vector_3 Vector;

// Point with normal vector stored in a std::pair.
typedef std::pair<Point, Vector> PointVectorPair;
typedef std::vector<PointVectorPair> PointList;

PointList points // Type of input point set

// simplification by clustering using erase-remove idiom

double cell_size = 0.001;

PointList::iterator unwanted_points_begin = CGAL::grid_simplify_point_set(points.begin(), points.end(), CGAL::First_of_pair_property_map<PointVectorPair>(), cell_size);

// delete unwanted points
points.erase(unwanted_points_begin , points.end());

// Optional: after erase(), use Scott Meyer's "swap trick" to trim excess capacity

PointList(points).swap(points);

Sorry for the earlier message,

Cheers,
Nad.

Nader SALMAN
    

Nader SALMAN a écrit :

Hi Tina,

thank you for your interest in CGAl and for using the PSP package.

here is how you should do it in general :

// kernel
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;

// Simple geometric types
typedef Kernel::FT FT;
typedef Kernel::Point_3 Point;
typedef Kernel::Vector_3 Vector;

// Point with normal vector stored in a std::pair.
typedef std::pair<Point, Vector> PointVectorPair;
typedef std::vector<PointVectorPair> PointList;

CGAL::grid_simplify_point_set(points.begin(), points.end(),
                                               CGAL::First_of_pair_property_map<PointVectorPair>(),
                                               cell_size);


in your case it would be :

 // simplification by clustering using erase-remove idiom
  double cell_size = 0.001;

  points.erase(CGAL::grid_simplify_point_set(points.begin(), points.end(),                                CGAL::First_of_pair_property_map<PointVectorPair>(), cell_size), points.end());

  // Optional: after erase(), use Scott Meyer's "swap trick" to trim excess capacity
  std::vector<Point>(points).swap(points);

Hope this helped!

Cheers,
Nad.

Nader SALMAN
Geometrica Lab, Byron Y308
INRIA Sophia Antipolis (FRANCE)

Tel: +33(0)4 9238 7161   Fax: +33(0)4 9715 5395   


http://www-sop.inria.fr/members/Nader.Salman

tina rumi a écrit :

Hi all,

I am trying to use following function:

points.erase(CGAL::grid_simplify_point_set(points.begin(), points.end(), cell_size),
               points.end());



the type that I am using for points is :

// types
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
typedef Kernel::Point_3 Point;
typedef Kernel::Vector_3 Vector;

// Point with normal vector stored in a std::pair.
typedef std::pair<Point, Vector> PointVectorPair;

std::list<PointVectorPair> points;

but it caused error. I want to keep this type for points. Do you have any suggestion to fix it.

Thank you,
Tina

Ce courrier électronique et toutes les pièces éventuellement jointes qu’il contient sont CONFIDENTIELS et destinés exclusivement à l’usage de leur destinataire. Si une erreur de transmission ou une adresse erronée a mal dirigée ce courrier, merci d’en informer l’expéditeur en lui faisant une réponse par courrier électronique dès réception. Si vous n’êtes pas le destinataire de ce courrier, vous ne devez pas l’utiliser, le conserver, en faire état, le distribuer, le copier, l’imprimer ou en révéler le contenu à une tierce partie.
Ce courrier électronique est à usage strictement informatif et ne saurait engager de quelque manière que ce soit INFOTERRA France SAS, ni ses filiales.

This e-mail and any attachments hereto are CONFIDENTIAL and intended solely for the use of the addressee. If you have received this e-mail in error please send it back to the person that sent it to you.
If you have received it in error, please notify the sender by return email. If you are not the addressee of this email, you must not use, keep, disseminate, copy, print or otherwise deal with it.
This email is for information only and will not bind INFOTERRA France SAS in any contract or obligation, nor its subsidiaries.
  

#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/property_map.h>
#include <CGAL/remove_outliers.h>
#include <CGAL/IO/read_xyz_points.h>
#include <CGAL/grid_simplify_point_set.h>
#include <CGAL/jet_smooth_point_set.h>
#include <CGAL/pca_estimate_normals.h>
#include <CGAL/mst_orient_normals.h>
#include <CGAL/property_map.h>
#include <CGAL/IO/write_xyz_points.h>

#include <vector>
#include <fstream>
#include <utility> // defines std::pair
#include <list>

// types

// kernel
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;

// Simple geometric types
typedef Kernel::FT FT;
typedef Kernel::Point_3 Point;
typedef Kernel::Vector_3 Vector;

// Point with normal vector stored in a std::pair.
typedef std::pair<Point, Vector> PointVectorPair;
typedef std::vector<PointVectorPair> PointList;

int main(void)
{

  PointList points; // Type of input point set

  // Reads a .xyz point set file in points[].
  // The Dereference_property_map property map can be omitted here as it is 
the default value.
  //std::list<PointVectorPair> points;

  std::ifstream stream("data/oni.xyz");
  if (!stream || !CGAL::read_xyz_points(stream, std::back_inserter(points),
    CGAL::First_of_pair_property_map<PointVectorPair>()))
  {
    std::cerr << "Error: cannot read file data" << std::endl;
    return EXIT_FAILURE;
  }

  // Removes outliers using erase-remove idiom.
  // The Dereference_property_map property map can be omitted here as it is 
the default value.
  const double removed_percentage = 5.0; // percentage of points to remove
  const int nb_neighbors = 24; // considers 24 nearest neighbor points
  points.erase(CGAL::remove_outliers(points.begin(), points.end(),
    CGAL::Dereference_property_map<Point>(),
    nb_neighbors, removed_percentage),
    points.end());


  // // Optional: after erase(), use Scott Meyer's "swap trick" to trim 
excess capacity
  //  PointList(points).swap(points);


  // simplification by clustering using erase-remove idiom
  double cell_size = 0.001;
  PointList::iterator unwanted_points_begin =
  CGAL::grid_simplify_point_set(points.begin(), points.end(),
                                
CGAL::First_of_pair_property_map<PointVectorPair>(), cell_size);

  // delete unwanted points
  points.erase(unwanted_points_begin , points.end());

  // Optional: after erase(), use Scott Meyer's "swap trick" to trim excess 
capacity
  PointList(points).swap(points);




  // Smoothing.
  const unsigned int nb_neighbors2 = 8; // default is 24 for real-life point 
sets
  CGAL::jet_smooth_point_set(points.begin(), points.end(), 
CGAL::First_of_pair_property_map<PointVectorPair>(), nb_neighbors2);

  // Estimates normals direction.
  // Note: pca_estimate_normals() requires an iterator over points
  // as well as property maps to access each point's position and normal.
  const int nb_neighbors3 = 18; // K-nearest neighbors = 3 rings
  CGAL::pca_estimate_normals(points.begin(), points.end(),
    CGAL::First_of_pair_property_map<PointVectorPair>(),
    CGAL::Second_of_pair_property_map<PointVectorPair>(),
    nb_neighbors3);


  // Orients normals.
  // Note: mst_orient_normals() requires an iterator over points
  // as well as property maps to access each point's position and normal.
  PointList::iterator unoriented_points_begin =
    CGAL::mst_orient_normals(points.begin(), points.end(),
    CGAL::First_of_pair_property_map<PointVectorPair>(),
    CGAL::Second_of_pair_property_map<PointVectorPair>(),
    nb_neighbors);

  // Optional: delete points with an unoriented normal
  // if you plan to call a reconstruction algorithm that expects oriented 
normals.
  points.erase(unoriented_points_begin, points.end());

  // Optional: after erase(), use Scott Meyer's "swap trick" to trim excess 
capacity
  PointList(points).swap(points);

  // Saves point set.
  // Note: write_xyz_points_and_normals() requires an output iterator
  // over points as well as property maps to access each
  // point position and normal.
  std::ofstream out("out_total.xyz");
  if (!out ||
    !CGAL::write_xyz_points_and_normals(
    out, points.begin(), points.end(),
    CGAL::First_of_pair_property_map<PointVectorPair>(),
    CGAL::Second_of_pair_property_map<PointVectorPair>()))
  {
    return EXIT_FAILURE;
  }


  return EXIT_SUCCESS;
}



//#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
//#include <CGAL/grid_simplify_point_set.h>
//#include <CGAL/IO/read_xyz_points.h>
//
//#include <vector>
//#include <fstream>
//
//// types
//typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
//typedef Kernel::Point_3 Point;
//
//int main(void)
//{
//  // Reads a .xyz point set file in points[].
//  std::vector<Point> points;
//  std::ifstream stream("data/oni.xyz");
//  if (!stream ||
//      !CGAL::read_xyz_points(stream, std::back_inserter(points)))
//  {
//    std::cerr << "Error: cannot read file data/oni.xyz" << std::endl;
//    return EXIT_FAILURE;
//  }
//
//  // simplification by clustering using erase-remove idiom
//  double cell_size = 0.001;
//  points.erase(CGAL::grid_simplify_point_set(points.begin(), points.end(), 
cell_size),
//               points.end());
//
//  // Optional: after erase(), use Scott Meyer's "swap trick" to trim excess 
capacity
//  std::vector<Point>(points).swap(points);
//
//  return EXIT_SUCCESS;
//}
//


//#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
//#include <CGAL/grid_simplify_point_set.h>
//#include <CGAL/IO/read_xyz_points.h>
//
//#include <vector>
//#include <fstream>
//
//// types
//typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
//typedef Kernel::Point_3 Point;
//
//int main(void)
//{
//  // Reads a .xyz point set file in points[].
//  std::vector<Point> points;
//  std::ifstream stream("data/oni.xyz");
//  if (!stream ||
//      !CGAL::read_xyz_points(stream, std::back_inserter(points)))
//  {
//    std::cerr << "Error: cannot read file data/oni.xyz" << std::endl;
//    return EXIT_FAILURE;
//  }
//
//  // simplification by clustering using erase-remove idiom
//  double cell_size = 0.001;
//  points.erase(CGAL::grid_simplify_point_set(points.begin(), points.end(), 
cell_size),
//               points.end());
//
//  // Optional: after erase(), use Scott Meyer's "swap trick" to trim excess 
capacity
//  std::vector<Point>(points).swap(points);
//
//  return EXIT_SUCCESS;
//}
//
// Copyright (c) 2007-09  INRIA Sophia-Antipolis (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you may redistribute point_it 
under
// the terms of the Q Public License version 1.0.
// See the file LICENSE.QPL distributed with CGAL.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the 
software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL: 
svn+ssh://scm.gforge.inria.fr/svn/cgal/branches/CGAL-3.5-branch/Point_set_processing_3/include/CGAL/grid_simplify_point_set.h
 $
// $Id: grid_simplify_point_set.h 49943 2009-06-17 07:49:35Z lsaboret $
//
// Author(s) : Nader Salman and Laurent Saboret

#ifndef CGAL_GRID_SIMPLIFY_POINT_SET_H
#define CGAL_GRID_SIMPLIFY_POINT_SET_H

#include <CGAL/property_map.h>
#include <CGAL/point_set_processing_assertions.h>

#include <iterator>
#include <set>
#include <deque>
#include <algorithm>
#include <cmath>

CGAL_BEGIN_NAMESPACE


// 
----------------------------------------------------------------------------
// Private section
// 
----------------------------------------------------------------------------
namespace CGALi {


/// Utility class for grid_simplify_point_set():
/// Less_epsilon_points_3 defines a 3D points order / 2 points are equal
/// iff they belong to the same cell of a grid of cell size = epsilon.
template <class Point_3, class PointPMap>
struct Less_epsilon_points_3
{
private:

    double m_epsilon;
    PointPMap point_pmap;

public:

    Less_epsilon_points_3 (double epsilon, PointPMap p_pmap) : m_epsilon 
(epsilon), point_pmap(p_pmap)
    {
        CGAL_point_set_processing_precondition(epsilon > 0);
    }

    bool operator() (const Point_3& a, const Point_3& b) const
    {
        typedef typename boost::property_traits<PointPMap>::value_type Point;
        // Round points to multiples of m_epsilon, then compare.
        
        Point a_n = get(point_pmap,&a);
        Point b_n = get(point_pmap,&b);
        
        Point rounded_a(round_epsilon(a_n.x(), m_epsilon),
                        round_epsilon(a_n.y(), m_epsilon),
                        round_epsilon(a_n.z(), m_epsilon));
                        
        Point rounded_b(round_epsilon(b_n.x(), m_epsilon),
                        round_epsilon(b_n.y(), m_epsilon),
                        round_epsilon(b_n.z(), m_epsilon));
                        
        return (rounded_a < rounded_b);
    }

private:

    // Round number to multiples of epsilon
    static inline double round_epsilon(double value, double epsilon)
    {
        return std::floor(value/epsilon) * epsilon;
    }
};


} /* namespace CGALi */


// 
----------------------------------------------------------------------------
// Public section
// 
----------------------------------------------------------------------------


/// Utility class for grid_simplify_point_set():
/// 3D points set which allows at most 1 point per cell
/// of a grid of cell size = epsilon.
///
/// Warning:
/// This class is a container sorted wrt points position
/// => you should not modify directly the order or the position of points.

template <class Point_3, class PointPMap>
class Epsilon_point_set_3 : public std::set<Point_3, 
CGALi::Less_epsilon_points_3<Point_3, PointPMap> >
{
private:

    // superclass
    typedef std::set<Point_3, CGALi::Less_epsilon_points_3<Point_3, 
PointPMap> > Base;

public:

    Epsilon_point_set_3 (double epsilon, PointPMap point_pmap) : Base( 
CGALi::Less_epsilon_points_3<Point_3,
                                                                       
PointPMap>(epsilon, point_pmap) )
    {
        CGAL_point_set_processing_precondition(epsilon > 0);
    }

    // default copy constructor, operator =() and destructor are fine.
};


/// Merges points which belong to the same cell of a grid of cell size = 
epsilon.
///
/// This method modifies the order of input points so as to pack all 
remaining points first,
/// and returns an iterator over the first point to remove (see erase-remove 
idiom).
/// For this reason it should not be called on sorted containers.
///
/// @commentheading Precondition: epsilon > 0.
///
/// @commentheading Template Parameters:
/// @param ForwardIterator iterator over input points.
/// @param PointPMap is a model of boost::ReadablePropertyMap with a 
value_type = Point_3<Kernel>.
///        It can be omitted if ForwardIterator value_type is convertible to 
Point_3<Kernel>.
/// @param Kernel Geometric traits class.
///        It can be omitted and deduced automatically from PointPMap 
value_type.
///
/// @return iterator over the first point to remove.

// This variant requires all parameters.
template <typename ForwardIterator,
          typename PointPMap,
          typename Kernel>
ForwardIterator grid_simplify_point_set(ForwardIterator first,  ///< iterator 
over the first input point.
                                        ForwardIterator beyond, ///< 
past-the-end iterator over the input points.
                                        PointPMap point_pmap,   ///< property 
map ForwardIterator -> Point_3
                                        double epsilon,         ///< 
tolerance value when merging 3D points.
                                        const Kernel& kernel)   ///< 
geometric traits.
{
  // actual type of input points
  typedef typename std::iterator_traits<ForwardIterator>::value_type 
Enriched_point;

  CGAL_point_set_processing_precondition(epsilon > 0);

  // Merges points which belong to the same cell of a grid of cell size = 
epsilon.
  // points_to_keep[] will contain 1 point per cell; the others will be in 
points_to_remove[].
  Epsilon_point_set_3<Enriched_point, PointPMap> points_to_keep(epsilon, 
point_pmap);
  std::deque<Enriched_point> points_to_remove;
  for (ForwardIterator it=first ; it != beyond ; it++)
  {
      std::pair<typename Epsilon_point_set_3<Enriched_point, 
PointPMap>::iterator,bool> result;
      result = points_to_keep.insert(*it);
      if (!result.second) // if not inserted
        points_to_remove.push_back(*it);
  }

  // Replaces [first, beyond) range by the content of points_to_keep, then 
points_to_remove.
  ForwardIterator first_point_to_remove = std::copy(points_to_keep.begin(), 
points_to_keep.end(), first);
                                          std::copy(points_to_remove.begin(), 
points_to_remove.end(), first_point_to_remove);

  return first_point_to_remove;
}

/// @cond SKIP_IN_MANUAL
// This variant deduces the kernel from the iterator type.
template <typename ForwardIterator,
          typename PointPMap
>
ForwardIterator
grid_simplify_point_set(
  ForwardIterator first, ///< iterator over the first input point
  ForwardIterator beyond, ///< past-the-end iterator
  PointPMap point_pmap, ///< property map ForwardIterator -> Point_3
  double epsilon) ///< tolerance value when merging 3D points
{
  typedef typename boost::property_traits<PointPMap>::value_type Point;
  typedef typename Kernel_traits<Point>::Kernel Kernel;
  return grid_simplify_point_set(
    first,beyond,
    point_pmap,
    epsilon,
    Kernel());
}
/// @endcond

/// @cond SKIP_IN_MANUAL
// This variant creates a default point property map = 
Dereference_property_map.
template <typename ForwardIterator
>
ForwardIterator
grid_simplify_point_set(
  ForwardIterator first, ///< iterator over the first input point
  ForwardIterator beyond, ///< past-the-end iterator
  double epsilon) ///< tolerance value when merging 3D points
{
  return grid_simplify_point_set( first,beyond, 
make_dereference_property_map(first), epsilon);
}
/// @endcond


CGAL_END_NAMESPACE

#endif // CGAL_GRID_SIMPLIFY_POINT_SET_H

//// Copyright (c) 2007-09  INRIA Sophia-Antipolis (France).
//// All rights reserved.
////
//// This file is part of CGAL (www.cgal.org); you may redistribute point_it 
under
//// the terms of the Q Public License version 1.0.
//// See the file LICENSE.QPL distributed with CGAL.
////
//// Licensees holding a valid commercial license may use this file in
//// accordance with the commercial license agreement provided with the 
software.
////
//// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
//// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
////
//// $URL: 
svn+ssh://scm.gforge.inria.fr/svn/cgal/branches/CGAL-3.5-branch/Point_set_processing_3/include/CGAL/grid_simplify_point_set.h
 $
//// $Id: grid_simplify_point_set.h 49943 2009-06-17 07:49:35Z lsaboret $
////
//// Author(s) : Laurent Saboret and Nader Salman
//
//#ifndef CGAL_GRID_SIMPLIFY_POINT_SET_H
//#define CGAL_GRID_SIMPLIFY_POINT_SET_H
//
//#include <CGAL/property_map.h>
//#include <CGAL/point_set_processing_assertions.h>
//
//#include <iterator>
//#include <set>
//#include <deque>
//#include <algorithm>
//#include <cmath>
//
//CGAL_BEGIN_NAMESPACE
//
//
//// 
----------------------------------------------------------------------------
//// Private section
//// 
----------------------------------------------------------------------------
//namespace CGALi {
//
//
///// Utility class for grid_simplify_point_set():
///// Less_epsilon_points_3 defines a 3D points order / 2 points are equal
///// iff they belong to the same cell of a grid of cell size = epsilon.
//template <class Point_3>
//struct Less_epsilon_points_3
//{
//private:
//
//    double m_epsilon;
//
//public:
//
//    Less_epsilon_points_3 (double epsilon)
//        : m_epsilon (epsilon)
//    {
//        CGAL_point_set_processing_precondition(epsilon > 0);
//    }
//
//    bool operator() (const Point_3& a, const Point_3& b) const
//    {
//        // Round points to multiples of m_epsilon, then compare.
//        Point_3 rounded_a(round_epsilon(a.x(), m_epsilon),
//                          round_epsilon(a.y(), m_epsilon),
//                          round_epsilon(a.z(), m_epsilon));
//        Point_3 rounded_b(round_epsilon(b.x(), m_epsilon),
//                          round_epsilon(b.y(), m_epsilon),
//                          round_epsilon(b.z(), m_epsilon));
//        return (rounded_a < rounded_b);
//    }
//
//private:
//
//    // Round number to multiples of epsilon
//    static inline double round_epsilon(double value, double epsilon)
//    {
//        return std::floor(value/epsilon) * epsilon;
//    }
//};
//
//
//} /* namespace CGALi */
//
//
//// 
----------------------------------------------------------------------------
//// Public section
//// 
----------------------------------------------------------------------------
//
//
///// Utility class for grid_simplify_point_set():
///// 3D points set which allows at most 1 point per cell
///// of a grid of cell size = epsilon.
/////
///// Warning:
///// This class is a container sorted wrt points position
///// => you should not modify directly the order or the position of points.
//
//template <class Point_3>
//class Epsilon_point_set_3
//  : public std::set<Point_3, CGALi::Less_epsilon_points_3<Point_3> >
//{
//private:
//
//    // superclass
//    typedef std::set<Point_3, CGALi::Less_epsilon_points_3<Point_3> > Base;
//
//public:
//
//    Epsilon_point_set_3 (double epsilon)
//        : Base( CGALi::Less_epsilon_points_3<Point_3>(epsilon) )
//    {
//        CGAL_point_set_processing_precondition(epsilon > 0);
//    }
//
//    // default copy constructor, operator =() and destructor are fine.
//};
//
//
///// Merges points which belong to the same cell of a grid of cell size = 
epsilon.
/////
///// This method modifies the order of input points so as to pack all 
remaining points first,
///// and returns an iterator over the first point to remove (see 
erase-remove idiom).
///// For this reason it should not be called on sorted containers.
/////
///// @commentheading Precondition: epsilon > 0.
/////
///// @commentheading Template Parameters:
///// @param ForwardIterator iterator over input points.
///// @param PointPMap is a model of boost::ReadablePropertyMap with a 
value_type = Point_3<Kernel>.
/////        It can be omitted if ForwardIterator value_type is convertible 
to Point_3<Kernel>.
///// @param Kernel Geometric traits class.
/////        It can be omitted and deduced automatically from PointPMap 
value_type.
/////
///// @return iterator over the first point to remove.
//
//// This variant requires all parameters.
//template <typename ForwardIterator,
//          typename PointPMap,
//          typename Kernel
//>
//ForwardIterator
//grid_simplify_point_set(
//  ForwardIterator first,  ///< iterator over the first input point.
//  ForwardIterator beyond, ///< past-the-end iterator over the input points.
//  PointPMap point_pmap, ///< property map ForwardIterator -> Point_3
//  double epsilon, ///< tolerance value when merging 3D points.
//  const Kernel& kernel) ///< geometric traits.
//{
//  // actual type of input points
//  typedef typename std::iterator_traits<ForwardIterator>::value_type 
Enriched_point;
//
//  CGAL_point_set_processing_precondition(epsilon > 0);
//
//  // Merges points which belong to the same cell of a grid of cell size = 
epsilon.
//  // points_to_keep[] will contain 1 point per cell; the others will be in 
points_to_remove[].
//  Epsilon_point_set_3<Enriched_point> points_to_keep(epsilon);
//  std::deque<Enriched_point> points_to_remove;
//  for (ForwardIterator it=first ; it != beyond ; it++)
//  {
//      std::pair<typename 
Epsilon_point_set_3<Enriched_point>::iterator,bool> result;
//      result = points_to_keep.insert(*it);
//      if (!result.second) // if not inserted
//        points_to_remove.push_back(*it);
//  }
//
//  // Replaces [first, beyond) range by the content of points_to_keep, then 
points_to_remove.
//  ForwardIterator first_point_to_remove =
//    std::copy(points_to_keep.begin(), points_to_keep.end(), first);
//  std::copy(points_to_remove.begin(), points_to_remove.end(), 
first_point_to_remove);
//
//  return first_point_to_remove;
//}
//
///// @cond SKIP_IN_MANUAL
//// This variant deduces the kernel from the iterator type.
//template <typename ForwardIterator,
//          typename PointPMap
//>
//ForwardIterator
//grid_simplify_point_set(
//  ForwardIterator first, ///< iterator over the first input point
//  ForwardIterator beyond, ///< past-the-end iterator
//  PointPMap point_pmap, ///< property map ForwardIterator -> Point_3
//  double epsilon) ///< tolerance value when merging 3D points
//{
//  typedef typename boost::property_traits<PointPMap>::value_type Point;
//  typedef typename Kernel_traits<Point>::Kernel Kernel;
//  return grid_simplify_point_set(
//    first,beyond,
//    point_pmap,
//    epsilon,
//    Kernel());
//}
///// @endcond
//
///// @cond SKIP_IN_MANUAL
//// This variant creates a default point property map = 
Dereference_property_map.
//template <typename ForwardIterator
//>
//ForwardIterator
//grid_simplify_point_set(
//  ForwardIterator first, ///< iterator over the first input point
//  ForwardIterator beyond, ///< past-the-end iterator
//  double epsilon) ///< tolerance value when merging 3D points
//{
//  return grid_simplify_point_set(
//    first,beyond,
//    make_dereference_property_map(first),
//    epsilon);
//}
///// @endcond
//
//
//CGAL_END_NAMESPACE
//
//#endif // CGAL_GRID_SIMPLIFY_POINT_SET_H
//