songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove trailing whitespace / tabs

This commit is contained in:
Mael Rouxel-Labbé 2020-05-22 15:31:50 +02:00
parent fb8463f470
commit 580a1efd5c
53 changed files with 1342 additions and 1342 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Alpha_shapes_3/include/CGAL/IO/Alpha_shape_3_VRML_2_ostream.h
View File

@ -74,7 +74,7 @@ operator<<(VRML_2_ostream& os,
os << Indent << " ";
for (int i=0; i<4; i++)
if (i != (*Flist_it).second){
os << V[(*Flist_it).first->vertex(i)];
os << V[(*Flist_it).first->vertex(i)];
os << ", ";
}
if (Flist_it != Flist_end)

12
BGL/doc/BGL/PackageDescription.txt
View File

@ -34,12 +34,12 @@ digraph example {
\cgalHeading{Notations}
<dl>
<dt>`G`</dt> <dd>A type that is a model of a graph concept.</dd>
<dt>`g`</dt> <dd>An object of type `G`.</dd>
<dt>`u`, `v`</dt> <dd>Objects of type `boost::graph_traits<G>::%vertex_descriptor`.</dd>
<dt>`h`</dt> <dd>An object of type `boost::graph_traits<G>::%halfedge_descriptor`.</dd>
<dt>`e`</dt> <dd>An object of type `boost::graph_traits<G>::%edge_descriptor`.</dd>
<dt>`f`</dt> <dd>An object of type `boost::graph_traits<G>::%face_descriptor`.</dd>
<dt>`G`</dt> <dd>A type that is a model of a graph concept.</dd>
<dt>`g`</dt> <dd>An object of type `G`.</dd>
<dt>`u`, `v`</dt> <dd>Objects of type `boost::graph_traits<G>::%vertex_descriptor`.</dd>
<dt>`h`</dt> <dd>An object of type `boost::graph_traits<G>::%halfedge_descriptor`.</dd>
<dt>`e`</dt> <dd>An object of type `boost::graph_traits<G>::%edge_descriptor`.</dd>
<dt>`f`</dt> <dd>An object of type `boost::graph_traits<G>::%face_descriptor`.</dd>
</dl>
\cgalHeading{%VertexListGraph}

88
Geomview/include/CGAL/IO/Geomview_stream.h
View File

@ -40,8 +40,8 @@ namespace CGAL {
class CGAL_EXPORT Geomview_stream {
public:
Geomview_stream(const Bbox_3 &bbox = Bbox_3(0,0,0, 1,1,1),
const char *machine = nullptr,
const char *login = nullptr);
const char *machine = nullptr,
const char *login = nullptr);
bool fail() const { return false; }
bool good() const { return true; }
@ -90,62 +90,62 @@ public:
double get_vertex_radius() const
{
return radius;
return radius;
}
double set_vertex_radius(double r)
{
std::swap(r, radius);
return r;
std::swap(r, radius);
return r;
}
int get_line_width() const
{
return line_width;
return line_width;
}
int set_line_width(int w)
{
std::swap(w, line_width);
std::swap(w, line_width);
return w;
}
bool set_wired(bool b)
{
std::swap(b, wired_flag);
return b;
std::swap(b, wired_flag);
return b;
}
bool get_wired() const
{
return wired_flag;
return wired_flag;
}
bool set_echo(bool b)
{
std::swap(b, echo_flag);
return b;
std::swap(b, echo_flag);
return b;
}
bool get_echo() const
{
return echo_flag;
return echo_flag;
}
bool set_raw(bool b)
{
std::swap(b, raw_flag);
return b;
std::swap(b, raw_flag);
return b;
}
bool get_raw() const
{
return raw_flag;
return raw_flag;
}
bool set_trace(bool b)
{
std::swap(b, trace_flag);
return b;
std::swap(b, trace_flag);
return b;
}
bool get_trace() const
{
return trace_flag;
return trace_flag;
}
void trace(const std::string s) const
@ -171,27 +171,27 @@ public:
bool set_binary_mode(bool b = true)
{
std::swap(b, binary_flag);
return b;
std::swap(b, binary_flag);
return b;
}
bool set_ascii_mode(bool b = true)
{
return !set_binary_mode(!b);
return !set_binary_mode(!b);
}
bool get_binary_mode() const
{
return binary_flag;
return binary_flag;
}
bool get_ascii_mode() const
{
return !binary_flag;
return !binary_flag;
}
std::string get_new_id(const std::string & s);
const Bbox_3 & get_bbox()
{
return bb;
return bb;
}
void pickplane()
@ -201,7 +201,7 @@ public:
static char* nth(char* s, int count);
static void parse_point(const char* pickpoint,
double &x, double &y, double &z, double &w);
double &x, double &y, double &z, double &w);
private:
void setup_geomview(const char *machine, const char *login);
void frame(const Bbox_3 &bbox);
@ -228,9 +228,9 @@ output_point(Geomview_stream &gv, const FT &x, const FT &y, const FT &z)
{
bool ascii_bak = true; // the initialization value shuts up the compiler.
if (!gv.get_raw()) {
ascii_bak = gv.set_ascii_mode();
gv << "(geometry " << gv.get_new_id("P")
<< " {appearance {linewidth 5 material {edgecolor "
ascii_bak = gv.set_ascii_mode();
gv << "(geometry " << gv.get_new_id("P")
<< " {appearance {linewidth 5 material {edgecolor "
<< gv.vcr() << gv.vcg() << gv.vcb() << "}}{SKEL 1 1 ";
}
@ -238,7 +238,7 @@ output_point(Geomview_stream &gv, const FT &x, const FT &y, const FT &z)
if (!gv.get_raw()) {
gv << "1 0\n}})";
gv.set_ascii_mode(ascii_bak);
gv.set_ascii_mode(ascii_bak);
}
}
@ -363,8 +363,8 @@ Geomview_stream::draw_triangles(InputIterator begin, InputIterator end)
std::vector<Point> points;
for (Tit i = triangles.begin(); i != triangles.end(); ++i)
for (int j = 0; j < 3; ++j)
if (point_map.insert(typename Point_map::value_type(i->vertex(j),
points.size())).second)
if (point_map.insert(typename Point_map::value_type(i->vertex(j),
points.size())).second)
points.push_back(i->vertex(j));
bool ascii_bak = get_ascii_mode();
@ -383,8 +383,8 @@ Geomview_stream::draw_triangles(InputIterator begin, InputIterator end)
// Triangles vertices indices.
for (Tit tit = triangles.begin(); tit != triangles.end(); ++tit) {
(*this) << 3;
for (int j = 0; j < 3; ++j)
(*this) << point_map[tit->vertex(j)];
for (int j = 0; j < 3; ++j)
(*this) << point_map[tit->vertex(j)];
(*this) << 0; // without color.
}
// Footer.
@ -487,14 +487,14 @@ operator<<(Geomview_stream &gv, const Ray_2<R> &r)
// Note: it won't work if double is not convertible to an RT...
const Bbox_3 & bb = gv.get_bbox();
Object result = intersection(Iso_rectangle_2<R>(
Point_2<R>(bb.xmin(), bb.ymin()),
Point_2<R>(bb.xmax(), bb.ymax())), r);
Point_2<R>(bb.xmin(), bb.ymin()),
Point_2<R>(bb.xmax(), bb.ymax())), r);
Point_2<R> ipoint;
Segment_2<R> iseg;
if (assign(ipoint, result))
gv << ipoint;
gv << ipoint;
else if (assign(iseg, result))
gv << iseg;
gv << iseg;
return gv;
}
#endif
@ -509,14 +509,14 @@ operator<<(Geomview_stream &gv, const Line_2<R> &r)
// Note: it won't work if double is not convertible to an RT...
const Bbox_3 & bb = gv.get_bbox();
Object result = intersection(Iso_rectangle_2<R>(
Point_2<R>(bb.xmin(), bb.ymin()),
Point_2<R>(bb.xmax(), bb.ymax())), r);
Point_2<R>(bb.xmin(), bb.ymin()),
Point_2<R>(bb.xmax(), bb.ymax())), r);
Point_2<R> ipoint;
Segment_2<R> iseg;
if (assign(ipoint, result))
gv << ipoint;
gv << ipoint;
else if (assign(iseg, result))
gv << iseg;
gv << iseg;
return gv;
}
#endif
@ -563,7 +563,7 @@ Geomview_stream&
operator>>(Geomview_stream &gv, Point_3<R> &point)
{
const char *gclpick =
"(pick world pickplane * nil nil nil nil nil nil nil)";
"(pick world pickplane * nil nil nil nil nil nil nil)";
bool ascii_bak = gv.set_ascii_mode();
gv << "(pickable pickplane yes) (ui-target pickplane yes)"
@ -580,7 +580,7 @@ operator>>(Geomview_stream &gv, Point_3<R> &point)
// we echo the input
if (gv.get_echo())
gv << point;
gv << point;
// we are done and tell geomview to stop sending pick events
gv << "(uninterest " << gclpick << ") (pickable pickplane no)";

14
Mesh_2/include/CGAL/IO/write_vtu.h
View File

@ -272,10 +272,10 @@ write_cdt_points(std::ostream& os,
template <class T>
void
write_attribute_tag_2 (std::ostream& os,
const std::string& attr_name,
const std::vector<T>& attribute,
bool binary,
std::size_t& offset)
const std::string& attr_name,
const std::vector<T>& attribute,
bool binary,
std::size_t& offset)
{
std::string format = binary ? "appended" : "ascii";
std::string type = (sizeof(T) == 8) ? "Float64" : "Float32";
@ -289,8 +289,8 @@ write_attribute_tag_2 (std::ostream& os,
typedef typename std::vector<T>::const_iterator Iterator;
os << "\">\n";
for (Iterator it = attribute.begin();
it != attribute.end();
++it )
it != attribute.end();
++it )
os << *it << " ";
os << " </DataArray>\n";
}
@ -300,7 +300,7 @@ write_attribute_tag_2 (std::ostream& os,
template <typename FT>
void
write_attributes_2(std::ostream& os,
const std::vector<FT>& att)
const std::vector<FT>& att)
{
IO::internal::write_vector(os,att);
}

28
Mesh_3/include/CGAL/IO/output_to_vtu.h
View File

@ -83,11 +83,11 @@ write_cells_tag(std::ostream& os,
os << ">\n";
std::size_t cells_offset = 0;
for( Cell_iterator cit = c3t3.cells_in_complex_begin() ;
cit != c3t3.cells_in_complex_end() ;
++cit )
cit != c3t3.cells_in_complex_end() ;
++cit )
{
cells_offset += 4;
os << cells_offset << " ";
cells_offset += 4;
os << cells_offset << " ";
}
os << "\n </DataArray>\n";
}
@ -104,8 +104,8 @@ write_cells_tag(std::ostream& os,
else {
os << ">\n";
for( Cell_iterator cit = c3t3.cells_in_complex_begin() ;
cit != c3t3.cells_in_complex_end() ;
++cit )
cit != c3t3.cells_in_complex_end() ;
++cit )
os << "10 ";
os << "\n </DataArray>\n";
}
@ -131,7 +131,7 @@ write_cells(std::ostream& os,
off += 4;
offsets.push_back(off);
for (int i=0; i<4; i++)
connectivity_table.push_back(V[cit->vertex(i)]);
connectivity_table.push_back(V[cit->vertex(i)]);
}
IO::internal::write_vector<std::size_t>(os,connectivity_table);
@ -219,10 +219,10 @@ write_c3t3_points(std::ostream& os,
template <class T>
void
write_attribute_tag(std::ostream& os,
const std::string& attr_name,
const std::vector<T>& attribute,
bool binary,
std::size_t& offset)
const std::string& attr_name,
const std::vector<T>& attribute,
bool binary,
std::size_t& offset)
{
std::string format = binary ? "appended" : "ascii";
std::string type = "";
@ -249,8 +249,8 @@ write_attribute_tag(std::ostream& os,
typedef typename std::vector<T>::const_iterator Iterator;
os << "\">\n";
for (Iterator it = attribute.begin();
it != attribute.end();
++it )
it != attribute.end();
++it )
os << *it << " ";
os << "\n </DataArray>\n";
}
@ -260,7 +260,7 @@ write_attribute_tag(std::ostream& os,
template <typename FT>
void
write_attributes(std::ostream& os,
const std::vector<FT>& att)
const std::vector<FT>& att)
{
IO::internal::write_vector(os,att);
}

22
Polygonal_surface_reconstruction/examples/Polygonal_surface_reconstruction/polyfit_example_model_complexty_control.cpp
View File

@ -6,10 +6,10 @@
#ifdef CGAL_USE_SCIP // defined (or not) by CMake scripts, do not define by hand
#include <CGAL/SCIP_mixed_integer_program_traits.h>
typedef CGAL::SCIP_mixed_integer_program_traits<double> MIP_Solver;
typedef CGAL::SCIP_mixed_integer_program_traits<double> MIP_Solver;
#elif defined(CGAL_USE_GLPK) // defined (or not) by CMake scripts, do not define by hand
#include <CGAL/GLPK_mixed_integer_program_traits.h>
typedef CGAL::GLPK_mixed_integer_program_traits<double> MIP_Solver;
typedef CGAL::GLPK_mixed_integer_program_traits<double> MIP_Solver;
#endif
@ -20,17 +20,17 @@ typedef CGAL::GLPK_mixed_integer_program_traits<double> MIP_Solver;
#include <fstream>
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
typedef Kernel::Point_3 Point;
typedef Kernel::Vector_3 Vector;
typedef CGAL::Polygonal_surface_reconstruction<Kernel> Polygonal_surface_reconstruction;
typedef CGAL::Surface_mesh<Point> Surface_mesh;
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
typedef Kernel::Point_3 Point;
typedef Kernel::Vector_3 Vector;
typedef CGAL::Polygonal_surface_reconstruction<Kernel> Polygonal_surface_reconstruction;
typedef CGAL::Surface_mesh<Point> Surface_mesh;
// Point with normal, and plane index
typedef boost::tuple<Point, Vector, int> PNI;
typedef CGAL::Nth_of_tuple_property_map<0, PNI> Point_map;
typedef CGAL::Nth_of_tuple_property_map<1, PNI> Normal_map;
typedef CGAL::Nth_of_tuple_property_map<2, PNI> Plane_index_map;
typedef boost::tuple<Point, Vector, int> PNI;
typedef CGAL::Nth_of_tuple_property_map<0, PNI> Point_map;
typedef CGAL::Nth_of_tuple_property_map<1, PNI> Normal_map;
typedef CGAL::Nth_of_tuple_property_map<2, PNI> Plane_index_map;
/*
* The following example shows how to control the model complexity by

22
Polygonal_surface_reconstruction/examples/Polygonal_surface_reconstruction/polyfit_example_user_provided_planes.cpp
View File

@ -6,10 +6,10 @@
#ifdef CGAL_USE_SCIP // defined (or not) by CMake scripts, do not define by hand
#include <CGAL/SCIP_mixed_integer_program_traits.h>
typedef CGAL::SCIP_mixed_integer_program_traits<double> MIP_Solver;
typedef CGAL::SCIP_mixed_integer_program_traits<double> MIP_Solver;
#elif defined(CGAL_USE_GLPK) // defined (or not) by CMake scripts, do not define by hand
#include <CGAL/GLPK_mixed_integer_program_traits.h>
typedef CGAL::GLPK_mixed_integer_program_traits<double> MIP_Solver;
typedef CGAL::GLPK_mixed_integer_program_traits<double> MIP_Solver;
#endif
@ -20,17 +20,17 @@ typedef CGAL::GLPK_mixed_integer_program_traits<double> MIP_Solver;
#include <fstream>
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
typedef Kernel::Point_3 Point;
typedef Kernel::Vector_3 Vector;
typedef CGAL::Polygonal_surface_reconstruction<Kernel> Polygonal_surface_reconstruction;
typedef CGAL::Surface_mesh<Point> Surface_mesh;
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
typedef Kernel::Point_3 Point;
typedef Kernel::Vector_3 Vector;
typedef CGAL::Polygonal_surface_reconstruction<Kernel> Polygonal_surface_reconstruction;
typedef CGAL::Surface_mesh<Point> Surface_mesh;
// Point with normal, and plane index
typedef boost::tuple<Point, Vector, int> PNI;
typedef CGAL::Nth_of_tuple_property_map<0, PNI> Point_map;
typedef CGAL::Nth_of_tuple_property_map<1, PNI> Normal_map;
typedef CGAL::Nth_of_tuple_property_map<2, PNI> Plane_index_map;
typedef boost::tuple<Point, Vector, int> PNI;
typedef CGAL::Nth_of_tuple_property_map<0, PNI> Point_map;
typedef CGAL::Nth_of_tuple_property_map<1, PNI> Normal_map;
typedef CGAL::Nth_of_tuple_property_map<2, PNI> Plane_index_map;
/*
* The following example shows the reconstruction using user-provided

16
Polygonal_surface_reconstruction/examples/Polygonal_surface_reconstruction/polyfit_example_with_region_growing.cpp
View File

@ -14,7 +14,7 @@ typedef CGAL::SCIP_mixed_integer_program_traits<double> MIP_Solver;
#elif defined(CGAL_USE_GLPK) // defined (or not) by CMake scripts, do not define by hand
#include <CGAL/GLPK_mixed_integer_program_traits.h>
typedef CGAL::GLPK_mixed_integer_program_traits<double> MIP_Solver;
typedef CGAL::GLPK_mixed_integer_program_traits<double> MIP_Solver;
#endif
@ -23,19 +23,19 @@ typedef CGAL::GLPK_mixed_integer_program_traits<double> MIP_Solver;
#include <fstream>
#include <CGAL/Timer.h>
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
typedef Kernel::FT FT;
typedef Kernel::Point_3 Point;
typedef Kernel::Point_3 Point;
typedef Kernel::Vector_3 Vector;
// Point with normal, and plane index.
typedef boost::tuple<Point, Vector, int> PNI;
typedef std::vector<PNI> Point_vector;
typedef CGAL::Nth_of_tuple_property_map<0, PNI> Point_map;
typedef CGAL::Nth_of_tuple_property_map<1, PNI> Normal_map;
typedef CGAL::Nth_of_tuple_property_map<2, PNI> Plane_index_map;
typedef CGAL::Nth_of_tuple_property_map<0, PNI> Point_map;
typedef CGAL::Nth_of_tuple_property_map<1, PNI> Normal_map;
typedef CGAL::Nth_of_tuple_property_map<2, PNI> Plane_index_map;
typedef CGAL::Shape_detection::Point_set::
Sphere_neighbor_query<Kernel, Point_vector, Point_map> Neighbor_query;
@ -44,8 +44,8 @@ Least_squares_plane_fit_region<Kernel, Point_vector, Point_map, Normal_map> Regi
typedef CGAL::Shape_detection::
Region_growing<Point_vector, Neighbor_query, Region_type> Region_growing;
typedef CGAL::Surface_mesh<Point> Surface_mesh;
typedef CGAL::Polygonal_surface_reconstruction<Kernel> Polygonal_surface_reconstruction;
typedef CGAL::Surface_mesh<Point> Surface_mesh;
typedef CGAL::Polygonal_surface_reconstruction<Kernel> Polygonal_surface_reconstruction;
class Index_map {

26
Polygonal_surface_reconstruction/examples/Polygonal_surface_reconstruction/polyfit_example_without_input_planes.cpp
View File

@ -8,12 +8,12 @@
#ifdef CGAL_USE_SCIP // defined (or not) by CMake scripts, do not define by hand
#include <CGAL/SCIP_mixed_integer_program_traits.h>
typedef CGAL::SCIP_mixed_integer_program_traits<double> MIP_Solver;
typedef CGAL::SCIP_mixed_integer_program_traits<double> MIP_Solver;
#elif defined(CGAL_USE_GLPK) // defined (or not) by CMake scripts, do not define by hand
#include <CGAL/GLPK_mixed_integer_program_traits.h>
typedef CGAL::GLPK_mixed_integer_program_traits<double> MIP_Solver;
typedef CGAL::GLPK_mixed_integer_program_traits<double> MIP_Solver;
#endif
@ -25,26 +25,26 @@ typedef CGAL::GLPK_mixed_integer_program_traits<double> MIP_Solver;
#include <fstream>
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
typedef Kernel::Point_3 Point;
typedef Kernel::Vector_3 Vector;
typedef Kernel::Point_3 Point;
typedef Kernel::Vector_3 Vector;
// Point with normal, and plane index
typedef boost::tuple<Point, Vector, int> PNI;
typedef std::vector<PNI> Point_vector;
typedef CGAL::Nth_of_tuple_property_map<0, PNI> Point_map;
typedef CGAL::Nth_of_tuple_property_map<1, PNI> Normal_map;
typedef CGAL::Nth_of_tuple_property_map<2, PNI> Plane_index_map;
typedef boost::tuple<Point, Vector, int> PNI;
typedef std::vector<PNI> Point_vector;
typedef CGAL::Nth_of_tuple_property_map<0, PNI> Point_map;
typedef CGAL::Nth_of_tuple_property_map<1, PNI> Normal_map;
typedef CGAL::Nth_of_tuple_property_map<2, PNI> Plane_index_map;
typedef CGAL::Shape_detection::Efficient_RANSAC_traits<Kernel, Point_vector, Point_map, Normal_map> Traits;
typedef CGAL::Shape_detection::Efficient_RANSAC<Traits> Efficient_ransac;
typedef CGAL::Shape_detection::Plane<Traits> Plane;
typedef CGAL::Shape_detection::Plane<Traits> Plane;
typedef CGAL::Shape_detection::Point_to_shape_index_map<Traits> Point_to_shape_index_map;
typedef CGAL::Polygonal_surface_reconstruction<Kernel> Polygonal_surface_reconstruction;
typedef CGAL::Surface_mesh<Point> Surface_mesh;
typedef CGAL::Polygonal_surface_reconstruction<Kernel> Polygonal_surface_reconstruction;
typedef CGAL::Surface_mesh<Point> Surface_mesh;
/*
* This example first extracts planes from the input point cloud

100
Ridges_3/examples/Ridges_3/Ridges_Umbilics_LCC.cpp
View File

@ -47,13 +47,13 @@ typedef boost::associative_property_map< Face2Vector_map > Face2Vector_property_
//RIDGES
typedef CGAL::Ridge_line<PolyhedralSurf> Ridge_line;
typedef CGAL::Ridge_approximation < PolyhedralSurf,
VertexFT_property_map,
VertexVector_property_map > Ridge_approximation;
VertexFT_property_map,
VertexVector_property_map > Ridge_approximation;
//UMBILICS
typedef CGAL::Umbilic<PolyhedralSurf> Umbilic;
typedef CGAL::Umbilic_approximation < PolyhedralSurf,
VertexFT_property_map,
VertexVector_property_map > Umbilic_approximation;
VertexFT_property_map,
VertexVector_property_map > Umbilic_approximation;
//create property maps
VertexFT_map vertex_k1_map, vertex_k2_map,
@ -86,8 +86,8 @@ unsigned int min_nb_points = (d_fitting + 1) * (d_fitting + 2) / 2;
*/
template <typename VertexPointMap>
void gather_fitting_points(vertex_descriptor v,
std::vector<Point_3> &in_points,
Poly_rings& poly_rings,
std::vector<Point_3> &in_points,
Poly_rings& poly_rings,
VertexPointMap vpm)
{
//container to collect vertices of v on the PolyhedralSurf
@ -148,7 +148,7 @@ void compute_differential_quantities(PolyhedralSurf& P, Poly_rings& poly_rings)
assert( d_monge >= 3);
// run the main fct : perform the fitting
monge_form = monge_fit(in_points.begin(), in_points.end(),
d_fitting, d_monge);
d_fitting, d_monge);
//switch min-max ppal curv/dir wrt the mesh orientation
const Vector_3 normal_mesh = computeFacetsAverageUnitNormal(P,v, face2normal_pm, Kernel());
@ -164,18 +164,18 @@ void compute_differential_quantities(PolyhedralSurf& P, Poly_rings& poly_rings)
if ( d_monge >= 4) {
//= 3*b1^2+(k1-k2)(c0-3k1^3)
vertex_P1_map[v] =
3*monge_form.coefficients()[3]*monge_form.coefficients()[3]
+(monge_form.coefficients()[0]-monge_form.coefficients()[1])
*(monge_form.coefficients()[6]
-3*monge_form.coefficients()[0]*monge_form.coefficients()[0]
*monge_form.coefficients()[0]);
3*monge_form.coefficients()[3]*monge_form.coefficients()[3]
+(monge_form.coefficients()[0]-monge_form.coefficients()[1])
*(monge_form.coefficients()[6]
-3*monge_form.coefficients()[0]*monge_form.coefficients()[0]
*monge_form.coefficients()[0]);
//= 3*b2^2+(k2-k1)(c4-3k2^3)
vertex_P2_map[v] =
3*monge_form.coefficients()[4]*monge_form.coefficients()[4]
+(-monge_form.coefficients()[0]+monge_form.coefficients()[1])
*(monge_form.coefficients()[10]
-3*monge_form.coefficients()[1]*monge_form.coefficients()[1]
*monge_form.coefficients()[1]);
3*monge_form.coefficients()[4]*monge_form.coefficients()[4]
+(-monge_form.coefficients()[0]+monge_form.coefficients()[1])
*(monge_form.coefficients()[10]
-3*monge_form.coefficients()[1]*monge_form.coefficients()[1]
*monge_form.coefficients()[1]);
}
} //END FOR LOOP
}
@ -228,8 +228,8 @@ int main()
if ( int_tag == 3 ) tag_order = CGAL::Ridge_order_3;
if ( int_tag == 4 ) tag_order = CGAL::Ridge_order_4;
if ( int_tag != 3 && int_tag != 4 )
{std::cerr << "ridge_order must be CGAL::Ridge_order_3 or CGAL::Ridge_order_4";
return 1;}
{std::cerr << "ridge_order must be CGAL::Ridge_order_3 or CGAL::Ridge_order_4";
return 1;}
}
#else
std::cerr << "Command-line options require Boost.ProgramOptions" << std::endl;
@ -261,26 +261,26 @@ int main()
if (of_name[i] == '/') of_name[i]='_';
std::ostringstream str_4ogl;
str_4ogl << "data/"
<< of_name << "RIDGES"
<< "-d" << d_fitting
<< "-m" << d_monge
<< "-t" << tag_order
<< "-a" << nb_rings
<< "-p" << nb_points_to_use
<< ".4ogl.txt";
<< of_name << "RIDGES"
<< "-d" << d_fitting
<< "-m" << d_monge
<< "-t" << tag_order
<< "-a" << nb_rings
<< "-p" << nb_points_to_use
<< ".4ogl.txt";
std::cout << str_4ogl.str() << std::endl ;
std::ofstream out_4ogl(str_4ogl.str().c_str() , std::ios::out);
//if verbose only...
std::ostringstream str_verb;
str_verb << "data/"
<< of_name << "RIDGES"
<< "-d" << d_fitting
<< "-m" << d_monge
<< "-t" << tag_order
<< "-a" << nb_rings
<< "-p" << nb_points_to_use
<< ".verb.txt";
<< of_name << "RIDGES"
<< "-d" << d_fitting
<< "-m" << d_monge
<< "-t" << tag_order
<< "-a" << nb_rings
<< "-p" << nb_points_to_use
<< ".verb.txt";
std::cout << str_verb.str() << std::endl ;
std::ofstream out_verb(str_verb.str().c_str() , std::ios::out);
@ -288,11 +288,11 @@ int main()
PolyhedralSurf P;
CGAL::read_OFF(if_name.c_str(), P);
fprintf(stderr, "loadMesh %d Ves %d Facets\n",
(int)num_vertices(P), (int)num_faces(P));
(int)num_vertices(P), (int)num_faces(P));
if(verbose)
out_verb << "Polysurf with " << num_vertices(P)
<< " vertices and " << num_faces(P)
<< " facets. " << std::endl;
<< " vertices and " << num_faces(P)
<< " facets. " << std::endl;
//exit if not enough points in the model
if (min_nb_points > num_vertices(P))
@ -313,10 +313,10 @@ int main()
//--------------------------------------------------------------------------
std::cout << "Compute ridges..." << std::endl;
Ridge_approximation ridge_approximation(P,
vertex_k1_pm, vertex_k2_pm,
vertex_b0_pm, vertex_b3_pm,
vertex_d1_pm, vertex_d2_pm,
vertex_P1_pm, vertex_P2_pm );
vertex_k1_pm, vertex_k2_pm,
vertex_b0_pm, vertex_b3_pm,
vertex_d1_pm, vertex_d2_pm,
vertex_P1_pm, vertex_P2_pm );
std::vector<Ridge_line*> ridge_lines;
std::back_insert_iterator<std::vector<Ridge_line*> > ii(ridge_lines);
@ -327,11 +327,11 @@ int main()
// or with the global function
CGAL::compute_max_ridges(P,
vertex_k1_pm, vertex_k2_pm,
vertex_b0_pm, vertex_b3_pm,
vertex_d1_pm, vertex_d2_pm,
vertex_P1_pm, vertex_P2_pm,
ii, tag_order);
vertex_k1_pm, vertex_k2_pm,
vertex_b0_pm, vertex_b3_pm,
vertex_d1_pm, vertex_d2_pm,
vertex_P1_pm, vertex_P2_pm,
ii, tag_order);
std::vector<Ridge_line*>::iterator iter_lines = ridge_lines.begin(),
iter_end = ridge_lines.end();
@ -360,14 +360,14 @@ int main()
//explicit construction of the class
// Umbilic_approximation umbilic_approximation(P,
// vertex_k1_pm, vertex_k2_pm,
// vertex_d1_pm, vertex_d2_pm);
// vertex_k1_pm, vertex_k2_pm,
// vertex_d1_pm, vertex_d2_pm);
// umbilic_approximation.compute(umb_it, umb_size);
//or global function call
CGAL::compute_umbilics(P,
vertex_k1_pm, vertex_k2_pm,
vertex_d1_pm, vertex_d2_pm,
umb_it, umb_size);
vertex_k1_pm, vertex_k2_pm,
vertex_d1_pm, vertex_d2_pm,
umb_it, umb_size);
std::vector<Umbilic*>::iterator iter_umb = umbilics.begin(),
iter_umb_end = umbilics.end();

2
Stream_support/examples/Stream_support/iv2off.cpp
View File

@ -258,7 +258,7 @@ int main( int argc, char **argv) {
}
if ( !*p_in) {
cerr << argv[0] << ": error: cannot open file '"<< iname
<< "' for reading." <<endl;
<< "' for reading." <<endl;
exit( 1);
}

2
Stream_support/include/CGAL/IO/OFF/Scanner_OFF.h
View File

@ -177,7 +177,7 @@ private:
public:
value_type::size_type size_of_indices () const // RO
{ return m_indices.size(); }
typedef value_type::size_type indices_size_type; // RO
typedef value_type::size_type indices_size_type; // RO
public:
typedef File_scanner_OFF Scanner;
typedef I_Scanner_OFF_facet_iterator Self;

6
Surface_mesher/doc/Surface_mesher/CGAL/IO/Complex_2_in_triangulation_3_file_writer.h
View File

@ -26,9 +26,9 @@ In case the surface is manifold the triangles can be oriented.
template <class SurfaceMeshComplex_2InTriangulation_3>
bool output_surface_facets_to_off (std::ostream& os,
const SurfaceMeshComplex_2InTriangulation_3& c2t3,
int options =
Surface_mesher::IO_ORIENT_SURFACE);
const SurfaceMeshComplex_2InTriangulation_3& c2t3,
int options =
Surface_mesher::IO_ORIENT_SURFACE);
namespace Surface_mesher {
/*!

332
Surface_mesher/include/CGAL/IO/Complex_2_in_triangulation_3_file_writer.h
View File

@ -46,13 +46,13 @@ namespace CGAL { namespace Surface_mesher {
}
bool write_header(const typename Tr::size_type number_of_vertices,
const typename Tr::size_type number_of_facets)
const typename Tr::size_type number_of_facets)
{
off.header().set_no_comments(true);
off.write_header(os,
number_of_vertices,
0, // fake number of halfedges, not used.
number_of_facets);
number_of_vertices,
0, // fake number of halfedges, not used.
number_of_facets);
return os.good();
}
@ -70,8 +70,8 @@ namespace CGAL { namespace Surface_mesher {
}
bool write_facet(const int index1,
const int index2,
const int index3)
const int index2,
const int index3)
{
off.write_facet_begin(3);
off.write_facet_vertex_index(index1);
@ -101,10 +101,10 @@ namespace CGAL { namespace Surface_mesher {
}
bool write_header(const typename Tr::size_type number_of_vertices,
const typename Tr::size_type number_of_facets)
const typename Tr::size_type number_of_facets)
{
builder.begin_surface(number_of_vertices,
number_of_facets);
number_of_facets);
return !builder.error();
}
@ -121,8 +121,8 @@ namespace CGAL { namespace Surface_mesher {
}
bool write_facet(const int index1,
const int index2,
const int index3)
const int index2,
const int index3)
{
int indices[3];
indices[0]=index1;
@ -140,16 +140,16 @@ namespace CGAL { namespace Surface_mesher {
}; // end class Write_to_HDS
enum IO_option { NO_OPTION = 0,
IO_ORIENT_SURFACE = 1,
IO_VERBOSE = 2 };
IO_ORIENT_SURFACE = 1,
IO_VERBOSE = 2 };
} // end namespace Surface_mesher
template <class C2t3>
bool output_surface_facets_to_off (std::ostream& os,
const C2t3& c2t3,
int options =
Surface_mesher::IO_ORIENT_SURFACE)
const C2t3& c2t3,
int options =
Surface_mesher::IO_ORIENT_SURFACE)
{
using CGAL::Surface_mesher::number_of_facets_on_surface;
@ -169,7 +169,7 @@ bool output_surface_facets_to_off (std::ostream& os,
off(os, (options & Surface_mesher::IO_VERBOSE) != 0);
success &= off.write_header(tr.number_of_vertices(),
c2t3.number_of_facets());
c2t3.number_of_facets());
CGAL_assertion(c2t3.number_of_facets() == number_of_facets_on_surface(tr));
@ -189,16 +189,16 @@ bool output_surface_facets_to_off (std::ostream& os,
if((options & Surface_mesher::IO_ORIENT_SURFACE) == 0)
{
for( Finite_facets_iterator fit = tr.finite_facets_begin();
fit != tr.finite_facets_end(); ++fit)
fit != tr.finite_facets_end(); ++fit)
{
const typename Tr::Cell_handle cell = fit->first;
const int& index = fit->second;
if (cell->is_facet_on_surface(index)==true)
{
const int index1 = V[cell->vertex(tr.vertex_triple_index(index, 0))];
const int index2 = V[cell->vertex(tr.vertex_triple_index(index, 1))];
const int index3 = V[cell->vertex(tr.vertex_triple_index(index, 2))];
success &= off.write_facet(index1, index2, index3);
const int index1 = V[cell->vertex(tr.vertex_triple_index(index, 0))];
const int index2 = V[cell->vertex(tr.vertex_triple_index(index, 1))];
const int index3 = V[cell->vertex(tr.vertex_triple_index(index, 2))];
success &= off.write_facet(index1, index2, index3);
}
}
}
@ -215,50 +215,50 @@ bool output_surface_facets_to_off (std::ostream& os,
while (oriented_set.size() != number_of_facets)
{
while ( fit->first->is_facet_on_surface(fit->second) == false ||
oriented_set.find(*fit) != oriented_set.end() ||
while ( fit->first->is_facet_on_surface(fit->second) == false ||
oriented_set.find(*fit) != oriented_set.end() ||
oriented_set.find(c2t3.opposite_facet(*fit)) !=
oriented_set.end() )
{
++fit;
}
oriented_set.insert(*fit);
stack.push(*fit);
while(! stack.empty() )
{
Facet f = stack.top();
stack.pop();
for(int ih = 0 ; ih < 3 ; ++ih) {
const int i1 = tr.vertex_triple_index(f.second, tr. cw(ih));
const int i2 = tr.vertex_triple_index(f.second, tr.ccw(ih));
oriented_set.find(c2t3.opposite_facet(*fit)) !=
oriented_set.end() )
{
++fit;
}
oriented_set.insert(*fit);
stack.push(*fit);
while(! stack.empty() )
{
Facet f = stack.top();
stack.pop();
for(int ih = 0 ; ih < 3 ; ++ih) {
const int i1 = tr.vertex_triple_index(f.second, tr. cw(ih));
const int i2 = tr.vertex_triple_index(f.second, tr.ccw(ih));
const typename C2t3::Face_status face_status
= c2t3.face_status(Edge(f.first, i1, i2));
if(face_status == C2t3::REGULAR) {
Facet fn = c2t3.neighbor(f, ih);
if (oriented_set.find(fn) == oriented_set.end()) {
if(oriented_set.find(c2t3.opposite_facet(fn)) == oriented_set.end())
{
oriented_set.insert(fn);
stack.push(fn);
}
else {
success = false; // non-orientable
}
}
}
else if(face_status != C2t3::BOUNDARY) {
success = false; // non manifold, thus non-orientable
}
} // end "for each neighbor of f"
} // end "stack non empty"
const typename C2t3::Face_status face_status
= c2t3.face_status(Edge(f.first, i1, i2));
if(face_status == C2t3::REGULAR) {
Facet fn = c2t3.neighbor(f, ih);
if (oriented_set.find(fn) == oriented_set.end()) {
if(oriented_set.find(c2t3.opposite_facet(fn)) == oriented_set.end())
{
oriented_set.insert(fn);
stack.push(fn);
}
else {
success = false; // non-orientable
}
}
}
else if(face_status != C2t3::BOUNDARY) {
success = false; // non manifold, thus non-orientable
}
} // end "for each neighbor of f"
} // end "stack non empty"
} // end "oriented_set not full"
for(typename std::set<Facet>::const_iterator fit =
oriented_set.begin();
fit != oriented_set.end();
++fit)
oriented_set.begin();
fit != oriented_set.end();
++fit)
{
const typename Tr::Cell_handle cell = fit->first;
const int& index = fit->second;
@ -289,89 +289,89 @@ bool output_surface_facets_to_off (std::ostream& os,
// CGAL::Polyhedron_incremental_builder_3<HalfedgeDS> builder(hds, true);
// const typename Tr::size_type number_of_facets = c2t3.number_of_facets();
// builder.begin_surface(tr.number_of_vertices(),
// number_of_facets);
// number_of_facets);
// {
// // Finite vertices coordinates.
// std::map<Vertex_handle, int> V;
// int inum = 0;
// for(Finite_vertices_iterator vit = tr.finite_vertices_begin();
// vit != tr.finite_vertices_end();
// ++vit)
// {
// V[vit] = inum++;
// Point p = static_cast<Point>(vit->point());
// builder.add_vertex(p);
// }
// Finite_facets_iterator fit = tr.finite_facets_begin();
// std::set<Facet> oriented_set;
// std::stack<Facet> stack;
// // Finite vertices coordinates.
// std::map<Vertex_handle, int> V;
// int inum = 0;
// for(Finite_vertices_iterator vit = tr.finite_vertices_begin();
// vit != tr.finite_vertices_end();
// ++vit)
// {
// V[vit] = inum++;
// Point p = static_cast<Point>(vit->point());
// builder.add_vertex(p);
// }
// Finite_facets_iterator fit = tr.finite_facets_begin();
// std::set<Facet> oriented_set;
// std::stack<Facet> stack;
// CGAL_assertion_code(typename Tr::size_type nb_facets = 0; )
// CGAL_assertion_code(typename Tr::size_type nb_facets = 0; )
// while (oriented_set.size() != number_of_facets) {
// while ( fit->first->is_facet_on_surface(fit->second) == false ||
// oriented_set.find(*fit) != oriented_set.end() ||
// while (oriented_set.size() != number_of_facets) {
// while ( fit->first->is_facet_on_surface(fit->second) == false ||
// oriented_set.find(*fit) != oriented_set.end() ||
// oriented_set.find(c2t3.opposite_facet(*fit)) !=
// oriented_set.end() ) {
// ++fit;
// }
// oriented_set.insert(*fit);
// stack.push(*fit);
// while(! stack.empty() ) {
// Facet f = stack.top();
// stack.pop();
// for(int ih = 0 ; ih < 3 ; ++ih) {
// const int i1 = tr.vertex_triple_index(f.second, tr. cw(ih));
// const int i2 = tr.vertex_triple_index(f.second, tr.ccw(ih));
// if( c2t3.face_status(Edge(f.first, i1, i2)) == C2t3::REGULAR ) {
// Facet fn = c2t3.neighbor(f, ih);
// if (oriented_set.find(fn) == oriented_set.end() &&
// oriented_set.find(c2t3.opposite_facet(fn)) == oriented_set.end())
// {
// oriented_set.insert(fn);
// stack.push(fn);
// }
// } // end "if the edge is regular"
// } // end "for each neighbor of f"
// } // end "stack non empty"
// } // end "oriented_set not full"
// oriented_set.find(c2t3.opposite_facet(*fit)) !=
// oriented_set.end() ) {
// ++fit;
// }
// oriented_set.insert(*fit);
// stack.push(*fit);
// while(! stack.empty() ) {
// Facet f = stack.top();
// stack.pop();
// for(int ih = 0 ; ih < 3 ; ++ih) {
// const int i1 = tr.vertex_triple_index(f.second, tr. cw(ih));
// const int i2 = tr.vertex_triple_index(f.second, tr.ccw(ih));
// if( c2t3.face_status(Edge(f.first, i1, i2)) == C2t3::REGULAR ) {
// Facet fn = c2t3.neighbor(f, ih);
// if (oriented_set.find(fn) == oriented_set.end() &&
// oriented_set.find(c2t3.opposite_facet(fn)) == oriented_set.end())
// {
// oriented_set.insert(fn);
// stack.push(fn);
// }
// } // end "if the edge is regular"
// } // end "for each neighbor of f"
// } // end "stack non empty"
// } // end "oriented_set not full"
// for(typename std::set<Facet>::const_iterator fit =
// oriented_set.begin();
// fit != oriented_set.end();
// ++fit)
// {
// int indices[3];
// int index = 0;
// for (int i=0; i<3; i++)
// indices[index++] =
// V[fit->first->vertex(tr.vertex_triple_index(fit->second, i))];
// builder.add_facet(indices+0, indices+3);
// CGAL_assertion_code(++nb_facets);
// }
// CGAL_assertion(nb_facets == number_of_facets);
// // for( Finite_facets_iterator fit = tr.finite_facets_begin();
// // fit != tr.finite_facets_end(); ++fit)
// // if ((*fit).first->is_facet_on_surface((*fit).second)==true)
// // {
// // int indices[3];
// // int index = 0;
// // for (int i=0; i<3; i++)
// // std::cerr << ( indices[index++] = V[(*fit).first->vertex(tr.vertex_triple_index(fit->second, i))] ) << ", ";
// // std::cerr << "\n";
// // if( builder.test_facet(indices+0, indices+3) )
// // builder.add_facet(indices+0, indices+3);
// // else
// // {
// // builder.begin_facet();
// // builder.add_vertex_to_facet(indices[2]);
// // builder.add_vertex_to_facet(indices[1]);
// // builder.add_vertex_to_facet(indices[0]);
// // builder.end_facet();
// // }
// // CGAL_assertion_code(++nb_facets);
// // }
// for(typename std::set<Facet>::const_iterator fit =
// oriented_set.begin();
// fit != oriented_set.end();
// ++fit)
// {
// int indices[3];
// int index = 0;
// for (int i=0; i<3; i++)
// indices[index++] =
// V[fit->first->vertex(tr.vertex_triple_index(fit->second, i))];
// builder.add_facet(indices+0, indices+3);
// CGAL_assertion_code(++nb_facets);
// }
// CGAL_assertion(nb_facets == number_of_facets);
// // for( Finite_facets_iterator fit = tr.finite_facets_begin();
// // fit != tr.finite_facets_end(); ++fit)
// // if ((*fit).first->is_facet_on_surface((*fit).second)==true)
// // {
// // int indices[3];
// // int index = 0;
// // for (int i=0; i<3; i++)
// // std::cerr << ( indices[index++] = V[(*fit).first->vertex(tr.vertex_triple_index(fit->second, i))] ) << ", ";
// // std::cerr << "\n";
// // if( builder.test_facet(indices+0, indices+3) )
// // builder.add_facet(indices+0, indices+3);
// // else
// // {
// // builder.begin_facet();
// // builder.add_vertex_to_facet(indices[2]);
// // builder.add_vertex_to_facet(indices[1]);
// // builder.add_vertex_to_facet(indices[0]);
// // builder.end_facet();
// // }
// // CGAL_assertion_code(++nb_facets);
// // }
// }
// builder.end_surface();
// }
@ -417,17 +417,17 @@ output_oriented_surface_facets_to_off (std::ostream& os, const Tr & T) {
fit != T.finite_facets_end(); ++fit)
if ((*fit).first->is_facet_on_surface((*fit).second)==true)
{
typename Tr::Facet f = *fit;
typename Tr::Facet opposite = T.mirror_facet(f);
CGAL_assertion (f.first->is_in_domain() !=
opposite.first->is_in_domain());
if(!f.first->is_in_domain())
f = T.mirror_facet(f);
os << "3 "
<< V[f.first->vertex(T.vertex_triple_index(f.second,0))] << " "
<< V[f.first->vertex(T.vertex_triple_index(f.second,1))] << " "
<< V[f.first->vertex(T.vertex_triple_index(f.second,2))] << " "
<< "\n"; // without color.
typename Tr::Facet f = *fit;
typename Tr::Facet opposite = T.mirror_facet(f);
CGAL_assertion (f.first->is_in_domain() !=
opposite.first->is_in_domain());
if(!f.first->is_in_domain())
f = T.mirror_facet(f);
os << "3 "
<< V[f.first->vertex(T.vertex_triple_index(f.second,0))] << " "
<< V[f.first->vertex(T.vertex_triple_index(f.second,1))] << " "
<< V[f.first->vertex(T.vertex_triple_index(f.second,2))] << " "
<< "\n"; // without color.
}
}
@ -435,8 +435,8 @@ output_oriented_surface_facets_to_off (std::ostream& os, const Tr & T) {
template < class Tr>
void
output_surface_facets_to_ghs (std::ostream& os_points,
std::ostream& os_faces,
const Tr & T) {
std::ostream& os_faces,
const Tr & T) {
typedef typename Tr::Finite_facets_iterator Finite_facets_iterator;
typedef typename Tr::Finite_vertices_iterator Finite_vertices_iterator;
typedef typename Tr::Vertex_handle Vertex_handle;
@ -466,15 +466,15 @@ output_surface_facets_to_ghs (std::ostream& os_points,
fit != T.finite_facets_end(); ++fit)
if ((*fit).first->is_facet_on_surface((*fit).second)==true)
{
Facet f = *fit;
if(!f.first->is_in_domain())
f = T.mirror_facet(f);
os_faces
<< "3 "
<< V[f.first->vertex(T.vertex_triple_index(f.second,0))] << " "
<< V[f.first->vertex(T.vertex_triple_index(f.second,1))] << " "
<< V[f.first->vertex(T.vertex_triple_index(f.second,2))] << " "
<< "0 0 0 0\n";
Facet f = *fit;
if(!f.first->is_in_domain())
f = T.mirror_facet(f);
os_faces
<< "3 "
<< V[f.first->vertex(T.vertex_triple_index(f.second,0))] << " "
<< V[f.first->vertex(T.vertex_triple_index(f.second,1))] << " "
<< V[f.first->vertex(T.vertex_triple_index(f.second,2))] << " "
<< "0 0 0 0\n";
}
}
@ -485,7 +485,7 @@ int number_of_facets_in_domain(const Tr& T) {
fit != T.finite_facets_end(); ++fit) {
typename Tr::Cell_handle neighb = fit->first->neighbor (fit->second);
if ((fit->first->is_in_domain () || neighb->is_in_domain()) &&
!fit->first->is_facet_on_surface (fit->second))
!fit->first->is_facet_on_surface (fit->second))
++result;
}
return result;
@ -522,14 +522,14 @@ output_interior_facets_to_off (std::ostream& os, const Tr & T) {
fit != T.finite_facets_end(); ++fit){
typename Tr::Cell_handle neighb = fit->first->neighbor (fit->second);
if ((fit->first->is_in_domain () || neighb->is_in_domain()) &&
!fit->first->is_facet_on_surface (fit->second))
!fit->first->is_facet_on_surface (fit->second))
{
os << "3 ";
for (int i=0; i<4; i++)
os << "3 ";
for (int i=0; i<4; i++)
if (i != (*fit).second)
os << V[(*fit).first->vertex(i)] << " ";
os << V[(*fit).first->vertex(i)] << " ";
os << "\n"; // without color.
os << "\n"; // without color.
}
}
}

308
TDS_2/include/CGAL/Triangulation_data_structure_2.h
View File

@ -128,15 +128,15 @@ public:
bool is_edge(Face_handle fh, int i) const;
bool is_edge(Vertex_handle va, Vertex_handle vb) const;
bool is_edge(Vertex_handle va, Vertex_handle vb,
Face_handle& fr, int& i) const;
Face_handle& fr, int& i) const;
bool is_face(Face_handle fh) const;
bool is_face(Vertex_handle v1,
Vertex_handle v2,
Vertex_handle v3) const;
Vertex_handle v2,
Vertex_handle v3) const;
bool is_face(Vertex_handle v1,
Vertex_handle v2,
Vertex_handle v3,
Face_handle& fr) const;
Vertex_handle v2,
Vertex_handle v3,
Face_handle& fr) const;
// ITERATORS AND CIRCULATORS
public:
@ -191,17 +191,17 @@ public:
}
Face_circulator incident_faces(Vertex_handle v,
Face_handle f = Face_handle()) const{
Face_handle f = Face_handle()) const{
return Face_circulator(v,f);
}
Vertex_circulator incident_vertices(Vertex_handle v,
Face_handle f = Face_handle()) const
Face_handle f = Face_handle()) const
{
return Vertex_circulator(v,f);
}
Edge_circulator incident_edges(Vertex_handle v,
Face_handle f = Face_handle()) const{
Face_handle f = Face_handle()) const{
return Edge_circulator(v,f);
}
@ -210,7 +210,7 @@ public:
Vertex_circulator vc = incident_vertices(v), done(vc);
if ( ! vc.is_empty()) {
do {
count += 1;
count += 1;
} while (++vc != done);
}
return count;
@ -221,7 +221,7 @@ public:
mirror_vertex(Face_handle f, int i) const
{
CGAL_triangulation_precondition ( f->neighbor(i) != Face_handle()
&& f->dimension() >= 1);
&& f->dimension() >= 1);
return f->neighbor(i)->vertex(mirror_index(f,i));
}
@ -230,7 +230,7 @@ public:
{
// return the index of opposite vertex in neighbor(i);
CGAL_triangulation_precondition (f->neighbor(i) != Face_handle() &&
f->dimension() >= 1);
f->dimension() >= 1);
if (f->dimension() == 1) {
CGAL_assertion(i<=1);
const int j = f->neighbor(i)->index(f->vertex((i==0) ? 1 : 0));
@ -257,7 +257,7 @@ public:
Vertex_handle insert_in_face(Face_handle f);
Vertex_handle insert_in_edge(Face_handle f, int i);
Vertex_handle insert_dim_up(Vertex_handle w = Vertex_handle(),
bool orient=true);
bool orient=true);
void remove_degree_3(Vertex_handle v, Face_handle f = Face_handle());
void remove_1D(Vertex_handle v);
@ -279,16 +279,16 @@ public:
// template< class EdgeIt, class FaceIt>
// Vertex_handle star_hole(EdgeIt edge_begin,
// EdgeIt edge_end,
// FaceIt face_begin,
// FaceIt face_end);
// EdgeIt edge_end,
// FaceIt face_begin,
// FaceIt face_end);
// template< class EdgeIt, class FaceIt>
// void star_hole(Vertex_handle v,
// EdgeIt edge_begin,
// EdgeIt edge_end,
// FaceIt face_begin,
// FaceIt face_end);
// EdgeIt edge_begin,
// EdgeIt edge_end,
// FaceIt face_begin,
// FaceIt face_end);
Vertex_handle create_vertex();
Vertex_handle create_vertex(const Vertex &v);
@ -298,20 +298,20 @@ public:
Face_handle create_face(Face_handle f); //calls copy constructor
Face_handle create_face(Face_handle f1, int i1,
Face_handle f2, int i2,
Face_handle f3, int i3);
Face_handle f2, int i2,
Face_handle f3, int i3);
Face_handle create_face(Face_handle f1, int i1,
Face_handle f2, int i2);
Face_handle f2, int i2);
Face_handle create_face(Face_handle f1, int i1, Vertex_handle v);
Face_handle create_face(Vertex_handle v1,
Vertex_handle v2,
Vertex_handle v3);
Vertex_handle v2,
Vertex_handle v3);
Face_handle create_face(Vertex_handle v1,
Vertex_handle v2,
Vertex_handle v3,
Face_handle f1,
Face_handle f2,
Face_handle f3);
Vertex_handle v2,
Vertex_handle v3,
Face_handle f1,
Face_handle f2,
Face_handle f3);
void set_adjacency(Face_handle f0, int i0, Face_handle f1, int i1) const;
@ -357,8 +357,8 @@ private:
typedef std::pair<Vertex_handle,Vertex_handle> Vh_pair;
public:
void set_adjacency(Face_handle fh,
int ih,
std::map< Vh_pair, Edge>& edge_map);
int ih,
std::map< Vh_pair, Edge>& edge_map);
void reorient_faces();
private:
bool dim_down_precondition(Face_handle f, int i);
@ -416,12 +416,12 @@ public:
// I/O
Vertex_handle file_input(std::istream& is, bool skip_first=false);
void file_output(std::ostream& os,
Vertex_handle v = Vertex_handle(),
bool skip_first=false) const;
Vertex_handle v = Vertex_handle(),
bool skip_first=false) const;
Vertex_handle off_file_input(std::istream& is, bool verbose=false);
void vrml_output(std::ostream& os,
Vertex_handle v = Vertex_handle(),
bool skip_first=false) const;
Vertex_handle v = Vertex_handle(),
bool skip_first=false) const;
// SETTING (had to make them public for use in remove from Triangulations)
void set_dimension (int n) {_dimension = n ;}
@ -550,19 +550,19 @@ public:
{
std::list<Face_handle> empty_list;
star_hole(v,
edge_begin,
edge_end,
empty_list.begin(),
empty_list.end());
edge_begin,
edge_end,
empty_list.begin(),
empty_list.end());
return;
}
template< class EdgeIt, class FaceIt>
Vertex_handle star_hole(EdgeIt edge_begin,
EdgeIt edge_end,
FaceIt face_begin,
FaceIt face_end)
EdgeIt edge_end,
FaceIt face_begin,
FaceIt face_end)
// creates a new vertex
// and stars from it
// the hole described by the range [edge_begin,edge_end[
@ -577,10 +577,10 @@ public:
template< class EdgeIt, class FaceIt>
void star_hole(Vertex_handle newv,
EdgeIt edge_begin,
EdgeIt edge_end,
FaceIt face_begin,
FaceIt face_end)
EdgeIt edge_begin,
EdgeIt edge_end,
FaceIt face_begin,
FaceIt face_end)
// uses vertex v
// to star the hole described by the range [edge_begin,edge_end[
// reusing the faces in the range [face_begin,face_end[
@ -615,10 +615,10 @@ public:
private:
template< class FaceIt>
Face_handle reset_or_create_face(Face_handle fn,
int in,
Vertex_handle v,
FaceIt& fit,
const FaceIt& face_end)
int in,
Vertex_handle v,
FaceIt& fit,
const FaceIt& face_end)
{
if (fit == face_end) return create_face(fn, in, v);
(*fit)->set_vertices(fn->vertex(cw(in)), fn->vertex(ccw(in)), v);
@ -790,7 +790,7 @@ template <class Vb, class Fb>
bool
Triangulation_data_structure_2<Vb,Fb>::
is_edge(Vertex_handle va, Vertex_handle vb,
Face_handle &fr, int & i) const
Face_handle &fr, int & i) const
// assume va is a vertex of t
// returns true (false) if the line segment ab is (is not) an edge of t
// if true is returned (fr,i) is the edge ab
@ -828,8 +828,8 @@ template <class Vb, class Fb>
inline bool
Triangulation_data_structure_2<Vb,Fb>::
is_face(Vertex_handle v1,
Vertex_handle v2,
Vertex_handle v3) const
Vertex_handle v2,
Vertex_handle v3) const
{
Face_handle f;
return is_face(v1,v2,v3,f);
@ -839,9 +839,9 @@ template <class Vb, class Fb>
bool
Triangulation_data_structure_2<Vb,Fb>::
is_face(Vertex_handle v1,
Vertex_handle v2,
Vertex_handle v3,
Face_handle &f) const
Vertex_handle v2,
Vertex_handle v3,
Face_handle &f) const
{
if (dimension() != 2) return false;
int i;
@ -896,7 +896,7 @@ Triangulation_data_structure_2<Vb,Fb>::
insert_first( )
{
CGAL_triangulation_precondition( number_of_vertices() == 0 &&
dimension()==-2 );
dimension()==-2 );
return insert_dim_up();
}
@ -906,7 +906,7 @@ Triangulation_data_structure_2<Vb,Fb>::
insert_second()
{
CGAL_triangulation_precondition( number_of_vertices() == 1 &&
dimension()==-1 );
dimension()==-1 );
return insert_dim_up();
}
@ -960,8 +960,8 @@ insert_in_edge(Face_handle f, int i)
CGAL_triangulation_precondition(f != Face_handle() && dimension() >= 1);
if (dimension() == 1) {CGAL_triangulation_precondition(i == 2);}
if (dimension() == 2) {CGAL_triangulation_precondition(i == 0 ||
i == 1 ||
i == 2);}
i == 1 ||
i == 2);}
Vertex_handle v;
if (dimension() == 1) {
v = create_vertex();
@ -1022,7 +1022,7 @@ insert_dim_up(Vertex_handle w, bool orient)
Face_iterator ib= face_iterator_base_begin();
Face_iterator ib_end = face_iterator_base_end();
for (; ib != ib_end ; ++ib){
faces_list.push_back( ib);
faces_list.push_back( ib);
}
std::list<Face_handle> to_delete;
@ -1030,51 +1030,51 @@ insert_dim_up(Vertex_handle w, bool orient)
Face_handle f, g;
for ( ; lfit != faces_list.end() ; ++lfit) {
f = * lfit;
g = create_face(f); //calls copy constructor of face
f->set_vertex(dim,v);
g->set_vertex(dim,w);
set_adjacency(f, dim, g, dim);
if (f->has_vertex(w)) to_delete.push_back(g); // flat face to delete
f = * lfit;
g = create_face(f); //calls copy constructor of face
f->set_vertex(dim,v);
g->set_vertex(dim,w);
set_adjacency(f, dim, g, dim);
if (f->has_vertex(w)) to_delete.push_back(g); // flat face to delete
}
lfit = faces_list.begin();
for ( ; lfit != faces_list.end() ; ++lfit) {
f = * lfit;
g = f->neighbor(dim);
for(int j = 0; j < dim ; ++j) {
g->set_neighbor(j, f->neighbor(j)->neighbor(dim));
}
f = * lfit;
g = f->neighbor(dim);
for(int j = 0; j < dim ; ++j) {
g->set_neighbor(j, f->neighbor(j)->neighbor(dim));
}
}
// couldn't unify the code for reorientation mater
lfit = faces_list.begin() ;
if (dim == 1){
if (orient) {
(*lfit)->reorient(); ++lfit ; (*lfit)->neighbor(1)->reorient();
}
else {
(*lfit)->neighbor(1)->reorient(); ++lfit ; (*lfit)->reorient();
}
if (orient) {
(*lfit)->reorient(); ++lfit ; (*lfit)->neighbor(1)->reorient();
}
else {
(*lfit)->neighbor(1)->reorient(); ++lfit ; (*lfit)->reorient();
}
}
else { // dimension == 2
for( ;lfit != faces_list.end(); ++lfit ) {
if (orient) {(*lfit)->neighbor(2)->reorient();}
else { (*lfit)->reorient();}
}
for( ;lfit != faces_list.end(); ++lfit ) {
if (orient) {(*lfit)->neighbor(2)->reorient();}
else { (*lfit)->reorient();}
}
}
lfit = to_delete.begin();
int i1, i2;
for ( ;lfit != to_delete.end(); ++lfit){
f = *lfit ;
int j ;
if (f->vertex(0) == w) {j=0;}
else {j=1;}
f1= f->neighbor(dim); i1= mirror_index(f,dim); //f1->index(f);
f2= f->neighbor(j); i2= mirror_index(f,j); //f2->index(f);
set_adjacency(f1, i1, f2, i2);
delete_face(f);
f = *lfit ;
int j ;
if (f->vertex(0) == w) {j=0;}
else {j=1;}
f1= f->neighbor(dim); i1= mirror_index(f,dim); //f1->index(f);
f2= f->neighbor(j); i2= mirror_index(f,j); //f2->index(f);
set_adjacency(f1, i1, f2, i2);
delete_face(f);
}
v->set_face( *(faces_list.begin()));
@ -1176,7 +1176,7 @@ dim_down(Face_handle f, int i)
Vertex_handle v1 = f->vertex(1);
f->set_vertex(1, v);
Face_handle fl = create_face(v, v1, Vertex_handle(),
n0, f, Face_handle());
n0, f, Face_handle());
f->set_neighbor(0, fl);
n0->set_neighbor(1, fl);
v->set_face(f);
@ -1217,15 +1217,15 @@ remove_dim_down(Vertex_handle v)
for( ; lfit != to_downgrade.end() ; ++lfit) {
f = *lfit; j = f->index(v);
if (dimension() == 1) {
if (j == 0) f->reorient();
f->set_vertex(1,Vertex_handle());
f->set_neighbor(1, Face_handle());
if (j == 0) f->reorient();
f->set_vertex(1,Vertex_handle());
f->set_neighbor(1, Face_handle());
}
else { //dimension() == 2
if (j == 0) f->cw_permute();
else if(j == 1) f->ccw_permute();
f->set_vertex(2, Vertex_handle());
f->set_neighbor(2, Face_handle());
if (j == 0) f->cw_permute();
else if(j == 1) f->ccw_permute();
f->set_vertex(2, Vertex_handle());
f->set_neighbor(2, Face_handle());
}
f->vertex(0)->set_face(f);
}
@ -1246,7 +1246,7 @@ Triangulation_data_structure_2<Vb,Fb>::
remove_1D(Vertex_handle v)
{
CGAL_triangulation_precondition( dimension() == 1 &&
number_of_vertices() > 3);
number_of_vertices() > 3);
Face_handle f = v->face();
int i = f->index(v);
if (i==0) {f = f->neighbor(1);}
@ -1268,7 +1268,7 @@ Triangulation_data_structure_2<Vb,Fb>::
remove_second(Vertex_handle v)
{
CGAL_triangulation_precondition(number_of_vertices()== 2 &&
dimension() == 0);
dimension() == 0);
remove_dim_down(v);
return;
}
@ -1280,7 +1280,7 @@ Triangulation_data_structure_2<Vb,Fb>::
remove_first(Vertex_handle v)
{
CGAL_triangulation_precondition(number_of_vertices()== 1 &&
dimension() == -1);
dimension() == -1);
remove_dim_down(v);
return;
}
@ -1404,13 +1404,13 @@ template <class Vb, class Fb>
typename Triangulation_data_structure_2<Vb,Fb>::Face_handle
Triangulation_data_structure_2<Vb,Fb>::
create_face(Face_handle f1, int i1,
Face_handle f2, int i2,
Face_handle f3, int i3)
Face_handle f2, int i2,
Face_handle f3, int i3)
{
Face_handle newf = faces().emplace(f1->vertex(cw(i1)),
f2->vertex(cw(i2)),
f3->vertex(cw(i3)),
f2, f3, f1);
f2->vertex(cw(i2)),
f3->vertex(cw(i3)),
f2, f3, f1);
f1->set_neighbor(i1,newf);
f2->set_neighbor(i2,newf);
f3->set_neighbor(i3,newf);
@ -1423,9 +1423,9 @@ Triangulation_data_structure_2<Vb,Fb>::
create_face(Face_handle f1, int i1, Face_handle f2, int i2)
{
Face_handle newf = faces().emplace(f1->vertex(cw(i1)),
f2->vertex(cw(i2)),
f2->vertex(ccw(i2)),
f2, Face_handle(), f1);
f2->vertex(cw(i2)),
f2->vertex(ccw(i2)),
f2, Face_handle(), f1);
f1->set_neighbor(i1,newf);
f2->set_neighbor(i2,newf);
return newf;
@ -1457,7 +1457,7 @@ template <class Vb, class Fb>
typename Triangulation_data_structure_2<Vb,Fb>::Face_handle
Triangulation_data_structure_2<Vb,Fb>::
create_face(Vertex_handle v1, Vertex_handle v2, Vertex_handle v3,
Face_handle f1, Face_handle f2, Face_handle f3)
Face_handle f1, Face_handle f2, Face_handle f3)
{
Face_handle newf = faces().emplace(v1, v2, v3, f1, f2, f3);
@ -1484,7 +1484,7 @@ delete_face(Face_handle f)
CGAL_triangulation_expensive_precondition( dimension() != 2 || is_face(f));
CGAL_triangulation_expensive_precondition( dimension() != 1 || is_edge(f,2));
CGAL_triangulation_expensive_precondition( dimension() != 0 ||
is_vertex(f->vertex(0)) );
is_vertex(f->vertex(0)) );
faces().erase(f);
}
@ -1671,7 +1671,7 @@ join_vertices(Face_handle f, int i, Vertex_handle v)
// / \ / \
// / \ g / \
// / bl \ / br \
// / \ / \
// / \ / \
// *---------*---------*
// ibl j=v4 ibr
//
@ -1687,9 +1687,9 @@ join_vertices(Face_handle f, int i, Vertex_handle v)
// * v1
// /|\
// / | \
// / | \
// / | \
// / bl|br \
// / | \
// / | \
// *-----*-----*
//
*/
@ -1788,7 +1788,7 @@ insert_degree_2(Face_handle f, int i)
// i / \
// * / \
// / \ / f \
// / \ / _____ \
// / \ / _____ \
// / f \ / / f1 \ \
// / \ |/ v \|
// v0=ccw(i) *---------* v1=cw(i) ===> v0 *----*----* v1
@ -1891,7 +1891,7 @@ is_valid(bool verbose, int level) const
result = result && (count_stored_faces == number_of_full_dim_faces());
CGAL_triangulation_assertion(
count_stored_faces == number_of_full_dim_faces());
count_stored_faces == number_of_full_dim_faces());
// vertex count
size_type vertex_count = 0;
@ -1996,8 +1996,8 @@ copy_tds(const TDS_src& tds_src,
fit1 = tds_src.faces().begin();
for ( ; fit1 != tds_src.faces_end(); ++fit1) {
for (int j = 0; j < dim ; ++j) {
fmap[fit1]->set_vertex(j, vmap[fit1->vertex(j)] );
fmap[fit1]->set_neighbor(j, fmap[fit1->neighbor(j)]);
fmap[fit1]->set_vertex(j, vmap[fit1->vertex(j)] );
fmap[fit1]->set_neighbor(j, fmap[fit1->neighbor(j)]);
}
}
@ -2096,10 +2096,10 @@ file_output( std::ostream& os, Vertex_handle v, bool skip_first) const
// other vertices
for( Vertex_iterator vit= vertices_begin(); vit != vertices_end() ; ++vit) {
if ( v != vit ) {
V[vit] = inum++;
// os << vit->point();
os << *vit;
if(is_ascii(os)) os << "\n";
V[vit] = inum++;
// os << vit->point();
os << *vit;
if(is_ascii(os)) os << "\n";
}
}
if(is_ascii(os)) os << "\n";
@ -2173,11 +2173,11 @@ file_input( std::istream& is, bool skip_first)
for(i = 0; i < m; ++i) {
F[i] = create_face() ;
for(int j = 0; j < dim ; ++j){
is >> index;
F[i]->set_vertex(j, V[index]);
// The face pointer of vertices is set too often,
// but otherwise we had to use a further map
V[index]->set_face(F[i]);
is >> index;
F[i]->set_vertex(j, V[index]);
// The face pointer of vertices is set too often,
// but otherwise we had to use a further map
V[index]->set_face(F[i]);
}
// read in non combinatorial info of the face
is >> *(F[i]) ;
@ -2188,8 +2188,8 @@ file_input( std::istream& is, bool skip_first)
{
for(i = 0; i < m; ++i) {
for(int j = 0; j < dimension()+1; ++j){
is >> index;
F[i]->set_neighbor(j, F[index]);
is >> index;
F[i]->set_neighbor(j, F[index]);
}
}
}
@ -2242,11 +2242,11 @@ vrml_output( std::ostream& os, Vertex_handle v, bool skip_infinite) const
// faces
for(fit= faces_begin(); fit != faces_end(); ++fit) {
if (!skip_infinite || !fit->has_vertex(v)) {
os << "\t\t\t";
os << vmap[(*fit).vertex(0)] << ", ";
os << vmap[(*fit).vertex(1)] << ", ";
os << vmap[(*fit).vertex(2)] << ", ";
os << "-1, " << std::endl;
os << "\t\t\t";
os << vmap[(*fit).vertex(0)] << ", ";
os << vmap[(*fit).vertex(1)] << ", ";
os << vmap[(*fit).vertex(2)] << ", ";
os << "-1, " << std::endl;
}
}
os << "\t\t]" << std::endl;
@ -2270,8 +2270,8 @@ off_file_input( std::istream& is, bool verbose)
if (! is) {
if (scanner.verbose()) {
std::cerr << " " << std::endl;
std::cerr << "TDS::off_file_input" << std::endl;
std::cerr << " input error: file format is not OFF." << std::endl;
std::cerr << "TDS::off_file_input" << std::endl;
std::cerr << " input error: file format is not OFF." << std::endl;
}
return vinf;
}
@ -2306,10 +2306,10 @@ off_file_input( std::istream& is, bool verbose)
scanner.scan_facet( no, i);
if( ! is || no != 3) {
if ( scanner.verbose()) {
std::cerr << " " << std::endl;
std::cerr << "TDS::off_file_input" << std::endl;
std::cerr << "facet " << i << "does not have 3 vertices."
<< std::endl;
std::cerr << " " << std::endl;
std::cerr << "TDS::off_file_input" << std::endl;
std::cerr << "facet " << i << "does not have 3 vertices."
<< std::endl;
}
is.clear( std::ios::badbit);
return vinf;
@ -2323,7 +2323,7 @@ off_file_input( std::istream& is, bool verbose)
}
for (std::size_t ih = 0; ih < no; ++ih) {
set_adjacency(fh, ih, edge_map);
set_adjacency(fh, ih, edge_map);
}
}
@ -2335,8 +2335,8 @@ off_file_input( std::istream& is, bool verbose)
Face_handle fh = edge_map.begin()->second.first;
int ih = edge_map.begin()->second.second;
Face_handle fn = create_face( vinf,
fh->vertex(cw(ih)),
fh->vertex(ccw(ih)));
fh->vertex(cw(ih)),
fh->vertex(ccw(ih)));
vinf->set_face(fn);
set_adjacency(fn, 0, fh, ih);
set_adjacency(fn, 1, inf_edge_map);
@ -2357,8 +2357,8 @@ template < class Vb, class Fb>
void
Triangulation_data_structure_2<Vb,Fb>::
set_adjacency(Face_handle fh,
int ih,
std::map< Vh_pair, Edge>& edge_map)
int ih,
std::map< Vh_pair, Edge>& edge_map)
{
// set adjacency to (fh,ih) using the the map edge_map
// or insert (fh,ih) in edge map
@ -2404,13 +2404,13 @@ reorient_faces()
Face_handle fh = st.top();
st.pop();
for(int ih = 0 ; ih < 3 ; ++ih){
Face_handle fn = fh->neighbor(ih);
if (oriented_set.insert(fn).second){
int in = fn->index(fh);
if (fn->vertex(cw(in)) != fh->vertex(ccw(ih))) fn->reorient();
Face_handle fn = fh->neighbor(ih);
if (oriented_set.insert(fn).second){
int in = fn->index(fh);
if (fn->vertex(cw(in)) != fh->vertex(ccw(ih))) fn->reorient();
--nf;
st.push(fn);
}
st.push(fn);
}
}
}
@ -2422,7 +2422,7 @@ reorient_faces()
template < class Vb, class Fb>
std::istream&
operator>>(std::istream& is,
Triangulation_data_structure_2<Vb,Fb>& tds)
Triangulation_data_structure_2<Vb,Fb>& tds)
{
tds.file_input(is);
return is;
@ -2432,7 +2432,7 @@ operator>>(std::istream& is,
template < class Vb, class Fb>
std::ostream&
operator<<(std::ostream& os,
const Triangulation_data_structure_2<Vb,Fb> &tds)
const Triangulation_data_structure_2<Vb,Fb> &tds)
{
tds.file_output(os);
return os;

124
Triangulation_2/examples/Triangulation_2/terr_trian.cpp
View File

@ -57,36 +57,36 @@ int main( int argc, char **argv) {
for (int i = 1; i < argc; i++) { // check commandline options
if ( strcmp( "-v", argv[i]) == 0)
verbose = true;
else if ( strcmp( "-b", argv[i]) == 0)
binary = true;
else if ( strcmp( "-noc", argv[i]) == 0)
noc = true;
else if ( strcmp( "-delaunay", argv[i]) == 0)
delaunay = true;
else if ( strcmp( "-incr", argv[i]) == 0)
incr = true;
else if ( strcmp( "-b", argv[i]) == 0)
binary = true;
else if ( strcmp( "-noc", argv[i]) == 0)
noc = true;
else if ( strcmp( "-delaunay", argv[i]) == 0)
delaunay = true;
else if ( strcmp( "-incr", argv[i]) == 0)
incr = true;
else if ( (strcmp( "-h", argv[i]) == 0) ||
(strcmp( "-help", argv[i]) == 0))
help = true;
else if ( n < 2 ) {
filename[ n++] = argv[i];
} else {
++n;
++n;
break;
}
}
}
if ((n > 2) || help) {
if ( ! help)
cerr << "Error: in parameter list" << endl;
cerr << "Usage: " << argv[0] << " [<options>] [<infile> [<outfile>]]"
<< endl;
cerr << " Terrain triangulation in the xy-plane." << endl;
cerr << " -delaunay Delaunay triangulation (default)." << endl;
cerr << " -incr Incremental insertion (no flips)." << endl;
cerr << " -b binary output (default is ASCII)." << endl;
cerr << " -noc no comments in file." << endl;
cerr << " -v verbose." << endl;
exit( ! help);
cerr << " Terrain triangulation in the xy-plane." << endl;
cerr << " -delaunay Delaunay triangulation (default)." << endl;
cerr << " -incr Incremental insertion (no flips)." << endl;
cerr << " -b binary output (default is ASCII)." << endl;
cerr << " -noc no comments in file." << endl;
cerr << " -v verbose." << endl;
exit( ! help);
}
CGAL::Verbose_ostream vout( verbose);
@ -96,77 +96,77 @@ int main( int argc, char **argv) {
istream* p_in = &cin;
ifstream in;
if ( n > 0) {
in.open( filename[0]);
p_in = &in;
iname = filename[0];
in.open( filename[0]);
p_in = &in;
iname = filename[0];
}
if ( !*p_in) {
cerr << argv[0] << ": error: cannot open file '" << iname
<< "' for reading." <<endl;
exit( 1);
cerr << argv[0] << ": error: cannot open file '" << iname
<< "' for reading." <<endl;
exit( 1);
}
CGAL::File_scanner_OFF scanner( * p_in, true);
if ( !*p_in)
exit( 1);
exit( 1);
const char* oname = "cout";
ostream* p_out = &cout;
ofstream out;
if ( n > 1) {
out.open( filename[1]);
p_out = &out;
oname = filename[1];
out.open( filename[1]);
p_out = &out;
oname = filename[1];
}
if ( !*p_out) {
cerr << argv[0] << ": error: cannot open file '"<< oname
<< "' for writing." <<endl;
exit( 1);
cerr << argv[0] << ": error: cannot open file '"<< oname
<< "' for writing." <<endl;
exit( 1);
}
// index array.
int* indices = new int[ scanner.size_of_vertices()];
for ( std::size_t k = 0; k < scanner.size_of_vertices(); k++)
indices[k] = -1;
indices[k] = -1;
if ( delaunay || ! incr) {
Delaunay_triangulation triang;
vout << "Scanning and triangulating ..." << endl;
for ( std::size_t j = 0; j < scanner.size_of_vertices(); j++) {
double x, y, z;
scanner.scan_vertex( x, y, z);
IPoint p( x, y, z, indices + j);
triang.insert( p);
}
vout << " .... done." << endl;
vout << "write_triangulation( " << oname
<< (binary ? ", binary" : ", ASCII") << ") ...." << endl;
CGAL::triangulation_print_OFF( *p_out, triang, binary, noc, verbose);
vout << " .... done." << endl;
Delaunay_triangulation triang;
vout << "Scanning and triangulating ..." << endl;
for ( std::size_t j = 0; j < scanner.size_of_vertices(); j++) {
double x, y, z;
scanner.scan_vertex( x, y, z);
IPoint p( x, y, z, indices + j);
triang.insert( p);
}
vout << " .... done." << endl;
vout << "write_triangulation( " << oname
<< (binary ? ", binary" : ", ASCII") << ") ...." << endl;
CGAL::triangulation_print_OFF( *p_out, triang, binary, noc, verbose);
vout << " .... done." << endl;
} else {
Triangulation triang;
vout << "Scanning and triangulating ..." << endl;
for ( std::size_t j = 0; j < scanner.size_of_vertices(); j++) {
double x, y, z;
scanner.scan_vertex( x, y, z);
IPoint p( x, y, z, indices + j);
triang.insert( p);
}
vout << " .... done." << endl;
vout << "write_triangulation( " << oname
<< (binary ? ", binary" : ", ASCII") << ") ...." << endl;
CGAL::triangulation_print_OFF( *p_out, triang, binary, noc, verbose);
vout << " .... done." << endl;
vout << "Scanning and triangulating ..." << endl;
for ( std::size_t j = 0; j < scanner.size_of_vertices(); j++) {
double x, y, z;
scanner.scan_vertex( x, y, z);
IPoint p( x, y, z, indices + j);
triang.insert( p);
}
vout << " .... done." << endl;
vout << "write_triangulation( " << oname
<< (binary ? ", binary" : ", ASCII") << ") ...." << endl;
CGAL::triangulation_print_OFF( *p_out, triang, binary, noc, verbose);
vout << " .... done." << endl;
}
if ( !*p_in) {
cerr << argv[0] << " read error: while reading file '"<< iname << "'."
<< endl;
exit( 1);
cerr << argv[0] << " read error: while reading file '"<< iname << "'."
<< endl;
exit( 1);
}
if ( !*p_out) {
cerr << argv[0] << " write error: while writing file '"<< oname << "'."
<< endl;
exit( 1);
cerr << argv[0] << " write error: while writing file '"<< oname << "'."
<< endl;
exit( 1);
}
delete[] indices;
return 0;