diff --git a/Installation/CHANGES.md b/Installation/CHANGES.md index aeb612f7cc6..8b4d67730cf 100644 --- a/Installation/CHANGES.md +++ b/Installation/CHANGES.md @@ -96,6 +96,16 @@ Release date: June 2020 does not allow any intersection, except for the configuration of two constraints having a single common endpoints, for convience. +### 3D Triangulations +- The free function `CGAL::file_input()` and the member function `CGAL::Triangulation_3::file_input()` + have been added. The first allows to load a `Triangulation_3` from an input stream, using functors to create vertices and cells. + The second is simply the member function version of the first one. + +### 3D Triangulation Data Structure +- The free function `CGAL::file_input()` and the member function `CGAL::TDS_3::file_input()` + have been added. The first allows to load a `TDS_3` from an input stream, using functors to create vertices and cells. + The second is simply the member function version of the first one. + ### dD Spatial Searching - Improved the performance of the kd-tree in some cases: diff --git a/Polyhedron/demo/Polyhedron/Plugins/Mesh_3/C3t3_io_plugin.cpp b/Polyhedron/demo/Polyhedron/Plugins/Mesh_3/C3t3_io_plugin.cpp index 4a85cb13b7e..d2232c11dd4 100644 --- a/Polyhedron/demo/Polyhedron/Plugins/Mesh_3/C3t3_io_plugin.cpp +++ b/Polyhedron/demo/Polyhedron/Plugins/Mesh_3/C3t3_io_plugin.cpp @@ -406,6 +406,11 @@ struct Update_vertex typedef typename Tr2::Vertex V2; typedef typename Tr2::Point Point; + V2 operator()(const V1&) + { + return V2(); + } + bool operator()(const V1& v1, V2& v2) { v2.set_point(Point(v1.point())); @@ -418,7 +423,7 @@ struct Update_vertex const Sp_index sp_index = boost::get(index); v2.set_index((std::max)(sp_index.first, sp_index.second)); } - break; + break; default:// -1, 0, 1, 3 v2.set_index(boost::get(v1.index())); } @@ -427,7 +432,9 @@ struct Update_vertex }; // end struct Update_vertex struct Update_cell { + typedef Fake_mesh_domain::Surface_patch_index Sp_index; + template bool operator()(const C1& c1, C2& c2) { c2.set_subdomain_index(c1.subdomain_index()); @@ -442,7 +449,6 @@ struct Update_cell { } }; // end struct Update_cell -#include template struct Update_vertex_from_CDT_3 { @@ -452,24 +458,28 @@ struct Update_vertex_from_CDT_3 { typedef typename Tr2::Vertex V2; typedef typename Tr2::Point Point; - bool operator()(const V1& v1, V2& v2) + V2 operator()(const V1&) + { + return V2(); + } + void operator()(const V1& v1, V2& v2) { v2.set_point(Point(v1.point())); v2.set_dimension(2); v2.set_special(false); - return true; } }; // end struct Update_vertex struct Update_cell_from_CDT_3 { + typedef Fake_mesh_domain::Surface_patch_index Sp_index; - template - bool operator()(const C1& c1, C2& c2) { + + template + void operator()(const C1& c1, C2& c2) { c2.set_subdomain_index(1); for(int i = 0; i < 4; ++i) { c2.set_surface_patch_index(i, c1.constrained_facet[i]); } - return true; } }; // end struct Update_cell @@ -500,11 +510,10 @@ try_load_a_cdt_3(std::istream& is, C3t3& c3t3) } } if(binary) CGAL::set_binary_mode(is); - if(CGAL::file_input< + if(c3t3.triangulation().file_input< Fake_CDT_3, - C3t3::Triangulation, Update_vertex_from_CDT_3, - Update_cell_from_CDT_3>(is, c3t3.triangulation())) + Update_cell_from_CDT_3>(is)) { c3t3.rescan_after_load_of_triangulation(); std::cerr << "Try load a CDT_3... DONE"; @@ -544,11 +553,10 @@ try_load_other_binary_format(std::istream& is, C3t3& c3t3) } if(binary) CGAL::set_binary_mode(is); else CGAL::set_ascii_mode(is); - std::istream& f_is = CGAL::file_input< + std::istream& f_is = c3t3.triangulation().file_input< Fake_c3t3::Triangulation, - C3t3::Triangulation, Update_vertex, - Update_cell>(is, c3t3.triangulation()); + Update_cell>(is); c3t3.rescan_after_load_of_triangulation(); return f_is.good(); diff --git a/Polyhedron/demo/Polyhedron/include/CGAL/Triangulation_file_input.h b/Polyhedron/demo/Polyhedron/include/CGAL/Triangulation_file_input.h deleted file mode 100644 index 9385f5b693f..00000000000 --- a/Polyhedron/demo/Polyhedron/include/CGAL/Triangulation_file_input.h +++ /dev/null @@ -1,103 +0,0 @@ -// Copyright (c) 1997-2010 INRIA Sophia-Antipolis (France). -// Copyright (c) 2011 GeometryFactory Sarl (France) -// All rights reserved. -// -// This file is part of CGAL (www.cgal.org); you may redistribute 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$ -// $Id$ -// -// Author(s) : Laurent Rineau -// - -// Adapted from operator>>(std::istream&, Triangulation_3&) from -// - -#ifndef CGAL_TRIANGULATION_FILE_INPUT_3_H -#define CGAL_TRIANGULATION_FILE_INPUT_3_H - -#include - -namespace CGAL { - -template -std::istream& file_input(std::istream& is, Tr2 &tr, - Update_vertex update_vertex = Update_vertex(), - Update_cell update_cell = Update_cell()) - // reads - // the dimension - // the number of finite vertices - // the non combinatorial information on vertices (point, etc) - // the number of cells - // the cells by the indices of their vertices in the preceding list - // of vertices, plus the non combinatorial information on each cell - // the neighbors of each cell by their index in the preceding list of cells - // when dimension < 3 : the same with faces of maximal dimension -{ - typedef Tr2 Triangulation; - typedef typename Triangulation::Vertex_handle Vertex_handle; - typedef typename Triangulation::Cell_handle Cell_handle; - - typedef typename Tr1::Vertex Vertex1; - typedef typename Tr1::Cell Cell1; - - tr.clear(); - tr.tds().cells().clear(); - - std::size_t n; - int d; - if(is_ascii(is)) - is >> d >> n; - else { - read(is, d); - read(is, n); - } - if(!is) return is; - tr.tds().set_dimension(d); - - std::vector< Vertex_handle > V(n+1); - V[0] = tr.infinite_vertex(); - // the infinite vertex is numbered 0 - - for (std::size_t i=1; i <= n; i++) { - V[i] = tr.tds().create_vertex(); - Vertex1 v; - if(!(is >> v)) return is; - if(!update_vertex(v, *V[i])) { - is.setstate(std::ios_base::failbit); - return is; - } - } - - std::vector< Cell_handle > C; - - std::size_t m; - tr.tds().read_cells(is, V, m, C); - - for (std::size_t j=0 ; j < m; j++) { - Cell1 c; - if(!(is >> c)) return is; - if(!update_cell(c, *(C[j]))) { - is.setstate(std::ios_base::failbit); - return is; - } - } - - CGAL_triangulation_assertion( tr.is_valid(false) ); - return is; -} - -} // end namespace CGAL - -#endif // CGAL_TRIANGULATION_FILE_INPUT_3_H diff --git a/TDS_3/doc/TDS_3/Concepts/TriangulationDataStructure_3.h b/TDS_3/doc/TDS_3/Concepts/TriangulationDataStructure_3.h index 8cdc8c934d2..081f9f98513 100644 --- a/TDS_3/doc/TDS_3/Concepts/TriangulationDataStructure_3.h +++ b/TDS_3/doc/TDS_3/Concepts/TriangulationDataStructure_3.h @@ -254,10 +254,10 @@ otherwise `Vertex_handle()` is returned. - A model of `ConvertVertex` must provide two operator()'s that are responsible for converting the source vertex `v_src` into the target vertex: - `Vertex operator()(const TDS_src::Vertex& v_src) const;` This operator is used to create the vertex from `v_src`. - - `void operator()(const TDS_src::Vertex& v_src, Vertex& v_tgt) const;` This operator is meant to be used in case heavy data should transferred to `v_tgt`. + - `void operator()(const TDS_src::Vertex& v_src, Vertex& v_tgt) const;` This operator is meant to be used in case heavy data should be transferred to `v_tgt`. - A model of ConvertCell must provide two operator()'s that are responsible for converting the source cell `c_src` into the target cell: - `Cell operator()(const TDS_src::Cell& c_src) const;` This operator is used to create the cell from `c_src`. - - `void operator()(const TDS_src::Cell& c_src, Cell& c_tgt) const;` This operator is meant to be used in case heavy data should transferred to `c_tgt`. + - `void operator()(const TDS_src::Cell& c_src, Cell& c_tgt) const;` This operator is meant to be used in case heavy data should be transferred to `c_tgt`. \pre The optional argument `v` is a vertex of `tds_src` or is `Vertex_handle()`. */ @@ -1024,17 +1024,52 @@ a precise indication on the kind of invalidity encountered. \cgalDebugEnd */ bool is_valid(Cell_handle c, bool verbose = false) const; +/// @} + +/// \name I/O +/// @{ /*! + \ingroup PkgIOTDS3 Reads a combinatorial triangulation from `is` and assigns it to `tds` */ istream& operator>> (istream& is, TriangulationDataStructure_3 & tds); -/*! +/*! \ingroup PkgIOTDS3 Writes `tds` into the stream `os` */ ostream& operator<< (ostream& os, const TriangulationDataStructure_3 & tds); +/*! \ingroup PkgIOTDS3 +The tds streamed in `is`, of original type `TDS_src`, is written into the triangulation data structure. As the vertex and cell + types might be different and incompatible, the creation of new cells and vertices +is made thanks to the functors `convert_vertex` and `convert_cell`, that convert +vertex and cell types. For each vertex `v_src` in `is`, the corresponding +vertex `v_tgt` in the triangulation data structure is a copy of the vertex returned by `convert_vertex(v_src)`. +The same operations are done for cells with the functor convert_cell, except cells +in the triangulation data structure are created using the default constructor, and then filled with the data +contained in the stream. + + - A model of `ConvertVertex` must provide two `operator()`s that are responsible + for converting the source vertex `v_src` into the target vertex: + - `Vertex operator()(const TDS_src::Vertex& v_src) const;` This operator is +used to create the vertex from `v_src`. + - `void operator()(const TDS_src::Vertex& v_src, Vertex& v_tgt) const;` This + operator is meant to be used in case heavy data should be transferred to `v_tgt`. + - A model of ConvertCell must provide an operator() that is responsible for +converting the source cell `c_src` into the target cell: + - `void operator()(const TDS_src::Cell& c_src, Cell& c_tgt) const;` This operator + is meant to be used in case heavy data should be transferred to `c_tgt`. + +\note The triangulation data structure contained in `is` can be obtained with the `operator>>` of a `TriangulationDataStructure_3`. +*/ +template +std::istream& file_input(std::istream& is, + ConvertVertex convert_vertex, + ConvertCell convert_cell); + /// @} }; /* end TriangulationDataStructure_3 */ diff --git a/TDS_3/doc/TDS_3/PackageDescription.txt b/TDS_3/doc/TDS_3/PackageDescription.txt index ee9b560977d..34f5d1acb1c 100644 --- a/TDS_3/doc/TDS_3/PackageDescription.txt +++ b/TDS_3/doc/TDS_3/PackageDescription.txt @@ -6,6 +6,8 @@ /// \defgroup PkgTDS3Classes Classes /// \ingroup PkgTDS3Ref +/// \defgroup PkgIOTDS3 I/O for a Triangulation_data_structure_3 +/// \ingroup PkgTDS3Ref /*! \addtogroup PkgTDS3Ref \todo check generated documentation diff --git a/TDS_3/include/CGAL/Triangulation_data_structure_3.h b/TDS_3/include/CGAL/Triangulation_data_structure_3.h index 968da3301ca..6e154098cb5 100644 --- a/TDS_3/include/CGAL/Triangulation_data_structure_3.h +++ b/TDS_3/include/CGAL/Triangulation_data_structure_3.h @@ -189,6 +189,7 @@ public: return hf ^ 419 * hs; } + }; static const int maximal_nb_of_facets_of_small_hole = 128; @@ -1521,6 +1522,73 @@ public: return s <= maximal_nb_of_facets_of_small_hole; } + //IO + template + std::istream& file_input(std::istream& is, + ConvertVertex convert_vertex = ConvertVertex(), + ConvertCell convert_cell = ConvertCell()) + { + // reads + // the dimension + // the number of finite vertices + // the non combinatorial information on vertices (point, etc) + // the number of cells + // the cells by the indices of their vertices in the preceding list + // of vertices, plus the non combinatorial information on each cell + // the neighbors of each cell by their index in the preceding list of cells + // when dimension < 3 : the same with faces of maximal dimension + + // If this is used for a TDS, the vertices are processed from 0 to n. + // Else, we make V[0] the infinite vertex and work from 1 to n+1. + + typedef typename Tds::Vertex_handle Vertex_handle; + typedef typename Tds::Cell_handle Cell_handle; + + typedef typename TDS_src::Vertex Vertex1; + typedef typename TDS_src::Cell Cell1; + clear(); + cells().clear(); + + std::size_t n; + int d; + if(is_ascii(is)) + is >> d >> n; + else { + read(is, d); + read(is, n); + } + if(!is) return is; + set_dimension(d); + + std::size_t V_size = n; + std::vector< Vertex_handle > V(V_size); + + // the infinite vertex is numbered 0 + for (std::size_t i=0 ; i < V_size; ++i) { + Vertex1 v; + if(!(is >> v)) return is; + Vertex_handle vh=create_vertex( convert_vertex(v) ); + V[i] = vh; + convert_vertex(v, *V[i]); + } + + std::vector< Cell_handle > C; + + std::size_t m; + read_cells(is, V, m, C); + + for (std::size_t j=0 ; j < m; j++) { + Cell1 c; + if(!(is >> c)) return is; + convert_cell(c, *C[j]); + } + + CGAL_triangulation_assertion(is_valid(false)); + return is; + } + private: // Change the orientation of the cell by swapping indices 0 and 1. @@ -1550,6 +1618,7 @@ private: // counts but does not check bool count_cells(size_type &i, bool verbose = false, int level = 0) const; // counts AND checks the validity + }; #ifdef CGAL_TDS_USE_RECURSIVE_CREATE_STAR_3 diff --git a/TDS_3/test/TDS_3/CMakeLists.txt b/TDS_3/test/TDS_3/CMakeLists.txt index 0253c40548c..b21488fe951 100644 --- a/TDS_3/test/TDS_3/CMakeLists.txt +++ b/TDS_3/test/TDS_3/CMakeLists.txt @@ -10,6 +10,7 @@ if ( CGAL_FOUND ) find_package( TBB QUIET ) create_single_source_cgal_program( "test_triangulation_tds_3.cpp" ) + create_single_source_cgal_program( "test_io_tds3.cpp" ) if(TBB_FOUND) CGAL_target_use_TBB(test_triangulation_tds_3) endif() diff --git a/TDS_3/test/TDS_3/test_io_tds3.cpp b/TDS_3/test/TDS_3/test_io_tds3.cpp new file mode 100644 index 00000000000..10bfcedc030 --- /dev/null +++ b/TDS_3/test/TDS_3/test_io_tds3.cpp @@ -0,0 +1,78 @@ +#include +#include +#include +#include +#include +#include +#include + +typedef CGAL::Triangulation_data_structure_3<> Tds; +typedef Tds::size_type size_type; +typedef Tds::Cell_handle Cell_handle; +typedef Tds::Vertex_handle Vertex_handle; + +template +struct Update_vertex +{ + typedef typename T1::Vertex V1; + typedef typename T2::Vertex V2; + + V2 operator()(const V1&) + { + return V2(); + } + + void operator()(const V1&, V2&) + { + + } + + +}; // end struct Update_vertex + +template +struct Update_cell +{ + typedef typename T1::Cell C1; + typedef typename T2::Cell C2; + + C2 operator()(const C1&) + { + return C2(); + } + + void operator()(const C1&, C2&) + { + + } + + +}; // end struct Update_vertex + +int main() +{ + Tds T; + std::vector PV(7); + PV[0] = T.insert_increase_dimension(); + // each of the following insertions of vertices increases the dimension + for ( int i=1; i<5; i++ ) { + PV[i] = T.insert_increase_dimension(PV[0]); + } + // we now have a simplex in dimension 4 + // cell incident to PV[0] + Cell_handle c = PV[0]->cell(); + int ind=0; + // PV[0] is the vertex of index ind in c + // insertion of a new vertex in the facet opposite to PV[0] + PV[5] = T.insert_in_facet(c, ind); + // insertion of a new vertex in c + PV[6] = T.insert_in_cell(c); + std::ofstream out("tr"); + out << T; + out.close(); + Tds T2; + std::ifstream in("tr"); + T2.file_input, Update_cell >(in); + in.close(); + return 0; +} diff --git a/Triangulation_3/doc/Triangulation_3/CGAL/Triangulation_3.h b/Triangulation_3/doc/Triangulation_3/CGAL/Triangulation_3.h index f419717feb1..e86c542c60d 100644 --- a/Triangulation_3/doc/Triangulation_3/CGAL/Triangulation_3.h +++ b/Triangulation_3/doc/Triangulation_3/CGAL/Triangulation_3.h @@ -1538,6 +1538,7 @@ for faces of maximal dimension instead of cells. /// @{ /*! +\ingroup PkgIOTriangulation3 Reads the underlying combinatorial triangulation from `is` by calling the corresponding input operator of the triangulation data structure class (note that the infinite vertex is numbered 0), and the @@ -1550,12 +1551,44 @@ of the vertex and cell types. Assigns the resulting triangulation to istream& operator>> (istream& is, Triangulation_3 &t); /*! + * \ingroup PkgIOTriangulation3 Writes the triangulation `t` into `os`. */ ostream& operator<< (ostream& os, const Triangulation_3 &t); -/// @} +/*! +\ingroup PkgIOTriangulation3 +The triangulation streamed in `is`, of original type `Tr_src`, is written into the triangulation. As the vertex and cell + types might be different and incompatible, the creation of new cells and vertices +is made thanks to the functors `convert_vertex` and `convert_cell`, that convert +vertex and cell types. For each vertex `v_src` in `is`, the corresponding +vertex `v_tgt` in the triangulation is a copy of the vertex returned by `convert_vertex(v_src)`. +The same operations are done for cells with the functor convert_cell, except cells +in the triangulation are created using the default constructor, and then filled with the data +contained in the stream. + - A model of `ConvertVertex` must provide two `operator()`s that are responsible + for converting the source vertex `v_src` into the target vertex: + - `Vertex operator()(const Tr_src::Vertex& v_src) const;` This operator is +used to create the vertex from `v_src`. + - `void operator()(const Tr_src::Vertex& v_src, Vertex& v_tgt) const;` This + operator is meant to be used in case heavy data should be transferred to `v_tgt`. + - A model of ConvertCell must provide an operator() that is responsible for +converting the source cell `c_src` into the target cell: + - `void operator()(const Tr_src::Cell& c_src, Cell& c_tgt) const;` This operator + is meant to be used in case data should be transferred to `c_tgt`. + +\note The triangulation contained in `is` can be obtained with the `operator>>` of a `Triangulation_3`. +*/ +template +std::istream& file_input(std::istream& is, + ConvertVertex convert_vertex = ConvertVertex(), + ConvertCell convert_cell = ConvertCell()); + +/// @} +/// /// \name Concurrency /// @{ diff --git a/Triangulation_3/doc/Triangulation_3/PackageDescription.txt b/Triangulation_3/doc/Triangulation_3/PackageDescription.txt index c401bad36c0..87cdc2aa9f7 100644 --- a/Triangulation_3/doc/Triangulation_3/PackageDescription.txt +++ b/Triangulation_3/doc/Triangulation_3/PackageDescription.txt @@ -21,6 +21,9 @@ /// \defgroup PkgDrawTriangulation3 Draw a Triangulation 3 /// \ingroup PkgTriangulation3Ref +/// \defgroup PkgIOTriangulation3 I/O for a Triangulation 3 +/// \ingroup PkgTriangulation3Ref + /*! \addtogroup PkgTriangulation3Ref \cgalPkgDescriptionBegin{3D Triangulations,PkgTriangulation3} @@ -121,5 +124,8 @@ is opposite to the vertex with the same index. See - \link PkgDrawTriangulation3 CGAL::draw() \endlink +\cgalCRPSection{I/O} + - \link PkgIOTriangulation3 CGAL:Triangulation_3::file_input()\endlink + - \link PkgIOTriangulation3 CGAL::file_input()\endlink */ diff --git a/Triangulation_3/include/CGAL/Triangulation_3.h b/Triangulation_3/include/CGAL/Triangulation_3.h index 5341859314a..c3f6e310f44 100644 --- a/Triangulation_3/include/CGAL/Triangulation_3.h +++ b/Triangulation_3/include/CGAL/Triangulation_3.h @@ -2196,8 +2196,80 @@ public: bool is_valid(bool verbose = false, int level = 0) const; bool is_valid(Cell_handle c, bool verbose = false, int level = 0) const; bool is_valid_finite(Cell_handle c, bool verbose = false, int level=0) const; + + //IO + template + std::istream& file_input(std::istream& is, + ConvertVertex convert_vertex = ConvertVertex(), + ConvertCell convert_cell = ConvertCell()) + { + // reads + // the dimension + // the number of finite vertices + // the non combinatorial information on vertices (point, etc) + // the number of cells + // the cells by the indices of their vertices in the preceding list + // of vertices, plus the non combinatorial information on each cell + // the neighbors of each cell by their index in the preceding list of cells + // when dimension < 3 : the same with faces of maximal dimension + + // If this is used for a TDS, the vertices are processed from 0 to n. + // Else, we make V[0] the infinite vertex and work from 1 to n+1. + + typedef Self Triangulation; + typedef typename Triangulation::Vertex_handle Vertex_handle; + typedef typename Triangulation::Cell_handle Cell_handle; + + typedef typename Tr_src::Vertex Vertex1; + typedef typename Tr_src::Cell Cell1; + + clear(); + tds().cells().clear(); + + std::size_t n; + int d; + if(is_ascii(is)) + is >> d >> n; + else { + read(is, d); + read(is, n); + } + if(!is) return is; + tds().set_dimension(d); + + std::size_t V_size = n+1; + std::vector< Vertex_handle > V(V_size); + + // the infinite vertex is numbered 0 + V[0] = infinite_vertex(); + + for (std::size_t i = 1; i < V_size; ++i) { + Vertex1 v; + if(!(is >> v)) return is; + Vertex_handle vh=tds().create_vertex( convert_vertex(v) ); + V[i] = vh; + convert_vertex(v, *V[i]); + } + + std::vector< Cell_handle > C; + + std::size_t m; + tds().read_cells(is, V, m, C); + + for (std::size_t j=0 ; j < m; j++) { + Cell1 c; + if(!(is >> c)) return is; + convert_cell(c, *C[j]); + } + + CGAL_triangulation_assertion( is_valid(false) ); + return is; + } }; + template < class GT, class Tds, class Lds > std::istream& operator>> (std::istream& is, Triangulation_3& tr) { diff --git a/Triangulation_3/test/Triangulation_3/CMakeLists.txt b/Triangulation_3/test/Triangulation_3/CMakeLists.txt index c4813394fc9..a2d10b47143 100644 --- a/Triangulation_3/test/Triangulation_3/CMakeLists.txt +++ b/Triangulation_3/test/Triangulation_3/CMakeLists.txt @@ -28,6 +28,7 @@ if ( CGAL_FOUND ) create_single_source_cgal_program( "test_simplex_3.cpp" ) create_single_source_cgal_program( "test_static_filters.cpp" ) create_single_source_cgal_program( "test_triangulation_3.cpp" ) + create_single_source_cgal_program( "test_io_triangulation_3.cpp" ) if(TBB_FOUND) foreach(target diff --git a/Triangulation_3/test/Triangulation_3/test_io_triangulation_3.cpp b/Triangulation_3/test/Triangulation_3/test_io_triangulation_3.cpp new file mode 100644 index 00000000000..a6e4694e5e1 --- /dev/null +++ b/Triangulation_3/test/Triangulation_3/test_io_triangulation_3.cpp @@ -0,0 +1,66 @@ + + +#include +#include +#include +#include +#include +#include + +typedef CGAL::Simple_cartesian K1; +typedef CGAL::Exact_predicates_inexact_constructions_kernel K2; +typedef CGAL::Triangulation_3 Tr1; +typedef CGAL::Triangulation_3 Tr2; + + +template +struct Update_vertex +{ + typedef typename T1::Vertex V1; + typedef typename T2::Vertex V2; + typedef typename T2::Point Point; + + V2 operator()(const V1&) + { + return V2(); + } + + void operator()(const V1& v1, V2& v2) + { + CGAL::Cartesian_converter c; + v2.set_point(Point(c(v1.point()))); + } +}; // end struct Update_vertex + +struct Update_cell { + template + void operator()(const C1&, C2&) {} +}; // end struct Update_cell +int main() +{ + // construction from a list of points : + std::list L; + L.push_back(Tr1::Point(0,0,0)); + L.push_back(Tr1::Point(1,0,0)); + L.push_back(Tr1::Point(0,1,0)); + L.push_back(Tr1::Point(0,0,1)); + Tr1 T1(L.begin(), L.end()); + std::ofstream out("tr"); + out << T1; + out.close(); + + Tr2 T2; + std::ifstream in("tr"); + T2.file_input, Update_cell>(in); + in.close(); + assert(T2.is_valid()); + Tr2::Point_iterator pit = T2.points_begin(); + assert(*(pit)++ == Tr2::Point(0,0,0)); + assert(*(pit)++ == Tr2::Point(1,0,0)); + assert(*(pit)++ == Tr2::Point(0,1,0)); + assert(*(pit)++ == Tr2::Point(0,0,1)); + + + std::cout << "done" << std::endl; + return 0; +}