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

Merge pull request #4671 from maxGimeno/DGAL-Fix_MIN_MAX_issues-maxGimeno 

CGAL: Min-max errors on windows
This commit is contained in:
Sebastien Loriot 2020-04-27 09:46:04 +02:00 committed by GitHub
parent e5c8db5745 c74bca8d65
commit 0325219ce6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
87 changed files with 291 additions and 291 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
AABB_tree/demo/AABB_tree/Scene.cpp
View File

@ -855,8 +855,8 @@ void Scene::update_grid_size()
}
void Scene::generate_points_in(const unsigned int nb_points,
const double min,
const double max)
const double vmin,
const double vmax)
{
if(m_pPolyhedron == NULL)
{
@ -875,7 +875,7 @@ void Scene::generate_points_in(const unsigned int nb_points,
CGAL::Timer timer;
timer.start();
std::cout << "Generate " << nb_points << " points in interval ["
<< min << ";" << max << "]";
<< vmin << ";" << vmax << "]";
unsigned int nb_trials = 0;
Vector vec = random_vector();
@ -892,8 +892,8 @@ void Scene::generate_points_in(const unsigned int nb_points,
if(nb_intersections % 2 != 0)
signed_distance *= -1.0;
if(signed_distance >= min &&
signed_distance <= max)
if(signed_distance >= vmin &&
signed_distance <= vmax)
{
m_points.push_back(p);
if(m_points.size()%(nb_points/10) == 0)

2
AABB_tree/demo/AABB_tree/Scene.h
View File

@ -192,7 +192,7 @@ public:
void generate_boundary_points(const unsigned int nb_points);
void generate_boundary_segments(const unsigned int nb_slices);
void generate_points_in(const unsigned int nb_points,
const double min, const double max);
const double vmin, const double vmax);
// algorithms/refine
void refine_loop();

8
Arrangement_on_surface_2/demo/Arrangement_on_surface_2/ArrangementDemoGraphicsView.cpp
View File

@ -109,10 +109,10 @@ QRectF ArrangementDemoGraphicsView::getViewportRect( ) const
QPointF p1 = this->mapToScene( 0, 0 );
QPointF p2 = this->mapToScene( this->width( ), this->height( ) );
double xmin = std::min( p1.x( ), p2.x( ) );
double xmax = std::max( p1.x( ), p2.x( ) );
double ymin = std::min( p1.y( ), p2.y( ) );
double ymax = std::max( p1.y( ), p2.y( ) );
double xmin = (std::min)( p1.x( ), p2.x( ) );
double xmax = (std::max)( p1.x( ), p2.x( ) );
double ymin = (std::min)( p1.y( ), p2.y( ) );
double ymax = (std::max)( p1.y( ), p2.y( ) );
QRectF res = QRectF( QPointF( xmin, ymin ), QPointF( xmax, ymax ) );

8
Arrangement_on_surface_2/include/CGAL/Curved_kernel_via_analysis_2/Arc_2.h
View File

@ -3024,8 +3024,8 @@ public:
y_dapprox = y_interval_for_curve_end(*this, CGAL::ARR_MIN_END, prec);
// adapt y-interval
ymin = CGAL::min(ymin, y_dapprox.first);
ymax = CGAL::max(ymax, y_dapprox.second);
ymin = (CGAL::min)(ymin, y_dapprox.first);
ymax = (CGAL::max)(ymax, y_dapprox.second);
// right end
@ -3105,9 +3105,9 @@ public:
(curr_xy, prec);
// adapt y-interval
ymin = CGAL::min(ymin,
ymin = (CGAL::min)(ymin,
CGAL::to_double(xy_approx.first));
ymax = CGAL::max(ymax,
ymax = (CGAL::max)(ymax,
CGAL::to_double(xy_approx.second));
}
}

6
Arrangement_on_surface_2/include/CGAL/Curved_kernel_via_analysis_2/gfx/Curve_renderer_2.h
View File

@ -572,7 +572,7 @@ void draw(const Arc_2& arc,
ref_bound = engine.pixel_h_r/CGAL_REFINE_X;
#ifdef CGAL_CKVA_RENDER_WITH_REFINEMENT
ref_bound = std::min(ref_bound, Rational(CGAL_REFINE_DOUBLE_APPROX));
ref_bound = (std::min)(ref_bound, Rational(CGAL_REFINE_DOUBLE_APPROX));
#endif
Gfx_OUT("computing y-coordinates\n");
@ -912,7 +912,7 @@ bool draw(const Point_2& pt, Coord_2& coord) {
const Coordinate_1& x0 = pt.x();
Rational ref_bound = engine.pixel_w_r / 2;
#ifdef CGAL_CKVA_RENDER_WITH_REFINEMENT
ref_bound = std::min(ref_bound, Rational(CGAL_REFINE_DOUBLE_APPROX));
ref_bound = (std::min)(ref_bound, Rational(CGAL_REFINE_DOUBLE_APPROX));
#endif
typename Curve_kernel_2::Algebraic_kernel_d_1::Approximate_relative_1
@ -932,7 +932,7 @@ bool draw(const Point_2& pt, Coord_2& coord) {
ref_bound = engine.pixel_h_r / CGAL_REFINE_X;
#ifdef CGAL_CKVA_RENDER_WITH_REFINEMENT
ref_bound = std::min(ref_bound, Rational(CGAL_REFINE_DOUBLE_APPROX));
ref_bound = (std::min)(ref_bound, Rational(CGAL_REFINE_DOUBLE_APPROX));
#endif
Coordinate_2 xy(x0, pt.curve(), pt.arcno());

2
BGL/include/CGAL/boost/graph/selection.h
View File

@ -140,7 +140,7 @@ struct Regularization_graph
if (get(pmap.rg->is_selected_map, fd))
{
if (pmap.rg->prevent_unselection)
out[0] = std::numeric_limits<double>::max();
out[0] = (std::numeric_limits<double>::max)();
else
out[0] = value;
out[1] = 0.;

4
Bounding_volumes/archive/test_extensive/stability/stability.cpp
View File

@ -17,8 +17,8 @@ int nr = 0;
double rerr(double exact,double approx) {
const double e = std::abs((exact-approx)/exact);
mine = std::min(mine,e);
maxe = std::max(maxe,e);
mine = (std::min)(mine,e);
maxe = (std::max)(maxe,e);
avge += e;
++nr;
return e;

24
Box_intersection_d/examples/Box_intersection_d/box_d_do_intersect_polylines.cpp
View File

@ -4,15 +4,15 @@
#include <CGAL/box_intersection_d.h>
template <typename Polyline>
template <typename Poly>
class Polylines_do_intersect
{
typedef typename Polyline::const_iterator Iterator;
typedef typename Poly::const_iterator Iterator;
typedef typename std::iterator_traits<Iterator>::value_type Point_2;
typedef typename CGAL::Kernel_traits<Point_2>::Kernel::Segment_2 Segment_2;
typedef CGAL::Bbox_2 Bbox_2;
const Polyline& pA, &pB;
const Poly& pA, &pB;
struct Box : public CGAL::Box_intersection_d::Box_with_handle_d<double,2,Iterator> {
@ -31,9 +31,9 @@ class Polylines_do_intersect
class Overlap {
const Polyline& pA, &pB;
const Poly& pA, &pB;
public:
Overlap(const Polyline& pA, const Polyline& pB)
Overlap(const Poly& pA, const Poly& pB)
: pA(pA), pB(pB)
{}
@ -49,7 +49,7 @@ class Polylines_do_intersect
public:
Polylines_do_intersect(const Polyline& pA, const Polyline& pB)
Polylines_do_intersect(const Poly& pA, const Poly& pB)
: pA(pA), pB(pB)
{}
@ -83,22 +83,22 @@ public:
};
template <typename Polyline>
bool polylines_do_intersect(const Polyline& pA,const Polyline& pB)
template <typename Poly>
bool polylines_do_intersect(const Poly& pA,const Poly& pB)
{
Polylines_do_intersect<Polyline> pdi(pA,pB);
Polylines_do_intersect<Poly> pdi(pA,pB);
return pdi();
}
typedef CGAL::Exact_predicates_inexact_constructions_kernel K;
typedef K::Point_2 Point_2;
typedef std::vector<Point_2> Polyline;
typedef std::vector<Point_2> CGAL_polyline;
int main()
{
Polyline pA = { Point_2(0,0), Point_2(1,0) };
Polyline pB = { Point_2(0,0), Point_2(0,1), Point_2(2,1) , Point_2(1,0)};
CGAL_polyline pA = { Point_2(0,0), Point_2(1,0) };
CGAL_polyline pB = { Point_2(0,0), Point_2(0,1), Point_2(2,1) , Point_2(1,0)};
if(polylines_do_intersect(pA,pB)){
std::cout << "intersection" << std::endl;

2
CGAL_ipelets/demo/CGAL_ipelets/alpha_shapes.cpp
View File

@ -94,7 +94,7 @@ void ASphapeIpelet::protected_run(int fn)
}
A.set_alpha(alpha==0?std::max(std::numeric_limits<double>::epsilon(),A.get_nth_alpha(0)/2.):
A.set_alpha(alpha==0?(std::max)(std::numeric_limits<double>::epsilon(),A.get_nth_alpha(0)/2.):
(std::size_t) alpha==A.number_of_alphas()?A.get_nth_alpha(alpha-1)+1:A.get_nth_alpha(alpha-1)/2.+A.get_nth_alpha(alpha)/2.);
for ( Alpha_shape_2::Alpha_shape_edges_iterator it=A.alpha_shape_edges_begin();it!=A.alpha_shape_edges_end();++it)
draw_in_ipe(A.segment(*it));

4
CGAL_ipelets/demo/CGAL_ipelets/diagrams.cpp
View File

@ -135,8 +135,8 @@ void diagrammeIpelet::protected_run(int fn)
Kernel::FT incr_len=(fn<2)?50:75;
//slightly increase the size of the Bbox
bbox=Iso_rectangle_2(bbox.min()+Kernel::Vector_2(-incr_len,-incr_len),
bbox.max()+Kernel::Vector_2(incr_len,incr_len));
bbox=Iso_rectangle_2((bbox.min)()+Kernel::Vector_2(-incr_len,-incr_len),
(bbox.max)()+Kernel::Vector_2(incr_len,incr_len));

4
CGAL_ipelets/demo/CGAL_ipelets/mesh_2.cpp
View File

@ -90,8 +90,8 @@ void IpeletMesh2::protected_run(int fn)
double alpha=0;
int x=static_cast<int>( floor(bbox.max().x()-bbox.min().x()) );
int y=static_cast<int>( floor(bbox.max().y()-bbox.min().y()) );
int x=static_cast<int>( floor((bbox.max)().x()-(bbox.min)().x()) );
int y=static_cast<int>( floor((bbox.max)().y()-(bbox.min)().y()) );
int ret_val;
boost::tie(ret_val,alpha)=request_value_from_user<double>((boost::format("Max edge length (BBox %1%x%2%)") % x % y).str() );

2
CGAL_ipelets/demo/CGAL_ipelets/minkowski.cpp
View File

@ -76,7 +76,7 @@ void SubSelectIpelet::protected_run(int fn)
for (std::list<Circle_2>::iterator it=cir_list.begin();it!=cir_list.end();++it)
r_offsets.push_back(sqrt(CGAL::to_double(it->squared_radius())));
IpeMatrix tfm (1,0,0,1,-CGAL::to_double(bbox.min().x()),-CGAL::to_double(bbox.min().y()));
IpeMatrix tfm (1,0,0,1,-CGAL::to_double((bbox.min)().x()),-CGAL::to_double((bbox.min)().y()));
for (std::list<Polygon_2>::iterator it=pol_list.begin();it!=pol_list.end();++it)
if(!it->is_simple()){

4
CGAL_ipelets/demo/CGAL_ipelets/multi_regular.cpp
View File

@ -95,8 +95,8 @@ void MregularIpelet::protected_run(int fn)
draw_in_ipe(rt);
else{//Draw kth Power diagram
double incr_len=75;
bbox=Iso_rectangle_2(bbox.min()+Kernel::Vector_2(-incr_len,-incr_len),
bbox.max()+Kernel::Vector_2(incr_len,incr_len));
bbox=Iso_rectangle_2((bbox.min)()+Kernel::Vector_2(-incr_len,-incr_len),
(bbox.max)()+Kernel::Vector_2(incr_len,incr_len));
draw_dual_in_ipe(rt,bbox); //draw Voronoi Diagram
}
}

2
CGAL_ipelets/demo/CGAL_ipelets/skeleton.cpp
View File

@ -105,7 +105,7 @@ void SkeletonIpelet::protected_run(int fn)
std::list<double> offsets;
//~ "Interior skeleton", "Exterior skeleton","Interior offset","Exterior offset","Interior offsets","Exterior offsets", "Help"
SkeletonPtr ss;
double max_edge=std::max((bbox.xmax()-bbox.xmin()),(bbox.ymax()-bbox.ymin()));
double max_edge=(std::max)((bbox.xmax()-bbox.xmin()),(bbox.ymax()-bbox.ymin()));
double dist=0.;
int ret_val=-1;
switch(fn){

4
CGAL_ipelets/demo/CGAL_ipelets/svdlinf.cpp
View File

@ -96,8 +96,8 @@ namespace CGAL_svdlinf {
Kernel::FT incr_len = 75;
// slightly increase the size of the bbox
bbox = Iso_rectangle_2(
bbox.min()+Kernel::Vector_2(-incr_len,-incr_len),
bbox.max()+Kernel::Vector_2(incr_len,incr_len));
(bbox.min)()+Kernel::Vector_2(-incr_len,-incr_len),
(bbox.max)()+Kernel::Vector_2(incr_len,incr_len));
for (std::list<Segment_2>::iterator
sit = sg_list.begin();

4
CGAL_ipelets/include/CGAL/CGAL_Ipelet_base_v6.h
View File

@ -256,8 +256,8 @@ public:
_page->DeselectAll();
Iso_rectangle_2 bbox_cgal(
static_cast<double>(bbox_ipe.Min().iX),static_cast<double>(bbox_ipe.Min().iY),
static_cast<double>(bbox_ipe.Max().iX),static_cast<double>(bbox_ipe.Max().iY)
static_cast<double>((bbox_ipe.Min)().iX),static_cast<double>((bbox_ipe.Min)().iY),
static_cast<double>((bbox_ipe.Max)().iX),static_cast<double>((bbox_ipe.Max)().iY)
);
return bbox_cgal;

4
Classification/include/CGAL/Classification/Feature/Cluster_vertical_extent.h
View File

@ -58,8 +58,8 @@ public:
m_values.reserve (clusters.size());
for (std::size_t i = 0; i < clusters.size(); ++ i)
{
float min_z = std::numeric_limits<float>::max();
float max_z = -std::numeric_limits<float>::min();
float min_z = (std::numeric_limits<float>::max)();
float max_z = -(std::numeric_limits<float>::min)();
for (std::size_t j = 0; j < clusters[i].size(); ++ j)
{

6
Classification/include/CGAL/Classification/Feature/Elevation.h
View File

@ -88,7 +88,7 @@ public:
Image_float dem(grid.width(),grid.height());
z_max = 0.f;
z_min = std::numeric_limits<float>::max();
z_min = (std::numeric_limits<float>::max)();
for (std::size_t j = 0; j < grid.height(); ++ j)
for (std::size_t i = 0; i < grid.width(); ++ i)
@ -100,8 +100,8 @@ public:
for (typename Grid::iterator it = grid.indices_begin(i,j); it != end; ++ it)
{
float z = float(get(point_map, *(input.begin()+(*it))).z());
z_min = (std::min(z_min, z));
z_max = (std::max(z_max, z));
z_min = ((std::min)(z_min, z));
z_max = ((std::max)(z_max, z));
mean += z;
++ nb;
}

4
Classification/include/CGAL/Classification/Feature/Height_above.h
View File

@ -81,13 +81,13 @@ public:
for (std::size_t i = 0; i < grid.width(); ++ i)
if (grid.has_points(i,j))
{
float z_max = -std::numeric_limits<float>::max();
float z_max = -(std::numeric_limits<float>::max)();
typename Grid::iterator end = grid.indices_end(i,j);
for (typename Grid::iterator it = grid.indices_begin(i,j); it != end; ++ it)
{
float z = float(get(point_map, *(input.begin()+(*it))).z());
z_max = (std::max(z_max, z));
z_max = ((std::max)(z_max, z));
}
dtm(i,j) = z_max;

4
Classification/include/CGAL/Classification/Feature/Height_below.h
View File

@ -81,13 +81,13 @@ public:
for (std::size_t i = 0; i < grid.width(); ++ i)
if (grid.has_points(i,j))
{
float z_min = std::numeric_limits<float>::max();
float z_min = (std::numeric_limits<float>::max)();
typename Grid::iterator end = grid.indices_end(i,j);
for (typename Grid::iterator it = grid.indices_begin(i,j); it != end; ++ it)
{
float z = float(get(point_map, *(input.begin()+(*it))).z());
z_min = (std::min(z_min, z));
z_min = ((std::min)(z_min, z));
}
dtm(i,j) = z_min;

8
Classification/include/CGAL/Classification/Feature/Vertical_range.h
View File

@ -81,15 +81,15 @@ public:
for (std::size_t i = 0; i < grid.width(); ++ i)
if (grid.has_points(i,j))
{
float z_max = -std::numeric_limits<float>::max();
float z_min = std::numeric_limits<float>::max();
float z_max = -(std::numeric_limits<float>::max)();
float z_min = (std::numeric_limits<float>::max)();
typename Grid::iterator end = grid.indices_end(i,j);
for (typename Grid::iterator it = grid.indices_begin(i,j); it != end; ++ it)
{
float z = float(get(point_map, *(input.begin()+(*it))).z());
z_max = (std::max(z_max, z));
z_min = (std::min(z_min, z));
z_max = ((std::max)(z_max, z));
z_min = ((std::min)(z_min, z));
}
dtm(i,j) = z_max - z_min;

8
Classification/include/CGAL/Classification/compressed_float.h
View File

@ -40,15 +40,15 @@ typedef unsigned short compressed_float;
typedef unsigned char compressed_float;
# endif
inline compressed_float compress_float (const float& f, const float& min = 0.f, const float& max = 1.f)
inline compressed_float compress_float (const float& f, const float& fmin = 0.f, const float& fmax = 1.f)
{
return static_cast<compressed_float>
(float(std::numeric_limits<compressed_float>::max()) * (f - min) / (max - min));
(float((std::numeric_limits<compressed_float>::max)()) * (f - fmin) / (fmax - fmin));
}
inline float decompress_float (const compressed_float& t, const float& min = 0.f, const float& max = 1.f)
inline float decompress_float (const compressed_float& t, const float& fmin = 0.f, const float& fmax = 1.f)
{
return ((max - min) * (t / float(std::numeric_limits<compressed_float>::max())) + min);
return ((fmax - fmin) * (t / float((std::numeric_limits<compressed_float>::max)())) + fmin);
}
#endif

2
Filtered_kernel/include/CGAL/internal/Static_filters/Coplanar_side_of_bounded_circle_3.h
View File

@ -126,7 +126,7 @@ public:
if (maxz < arz) maxz = arz;
if (maxz < atz) maxz = atz;
double d = std::max(maxx, std::max(maxy, maxz));
double d = (std::max)(maxx, (std::max)(maxy, maxz));
double eps = 3.27418e-11 * d * d * d * d * d * d;
if (det > eps) return ON_BOUNDED_SIDE;

8
Heat_method_3/examples/Heat_method_3/heat_method_surface_mesh.cpp
View File

@ -38,20 +38,20 @@ int main(int argc, char* argv[])
Point_3 sp = tm.point(source);
std::cout << "source: " << sp << " " << source << std::endl;
vertex_descriptor far;
vertex_descriptor vfar;
double sdistance = 0;
for(vertex_descriptor vd : vertices(tm)){
std::cout << vd << " is at distance " << get(vertex_distance, vd) << " to " << source << std::endl;
if(get(vertex_distance, vd) > sdistance){
far = vd;
vfar = vd;
sdistance = get(vertex_distance, vd);
}
}
std::cout << "far: " << tm.point(far) << " " << far << std::endl;
std::cout << "vfar: " << tm.point(vfar) << " " << vfar << std::endl;
hm.add_source(far);
hm.add_source(vfar);
hm.estimate_geodesic_distances(vertex_distance);
for(vertex_descriptor vd : vertices(tm)){

6
Heat_method_3/test/Heat_method_3/heat_method_concept.cpp
View File

@ -42,19 +42,19 @@ int main()
//Point_3 sp = sm.point(source);
vertex_descriptor far;
vertex_descriptor vfar;
// double sdistance = 0;
for(vertex_descriptor vd : vertices(sm)){
std::cout << vd << " is at distance " << get(heat_intensity, vd) << " from " << source << std::endl;
/*
if(squared_distance(sp,sm.point(vd)) > sdistance){
far = vd;
vfar = vd;
sdistance = squared_distance(sp,sm.point(vd));
}
*/
}
hm.add_source(far);
hm.add_source(vfar);
hm.estimate_geodesic_distances(heat_intensity);
for(vertex_descriptor vd : vertices(sm)){

10
Heat_method_3/test/Heat_method_3/heat_method_surface_mesh_direct_test.cpp
View File

@ -36,19 +36,19 @@ int main(int argc, char* argv[])
Point_3 sp = sm.point(source);
std::cout << "source: " << sp << " " << source << std::endl;
vertex_descriptor far;
vertex_descriptor vfar;
double sdistance = 0;
for(vertex_descriptor vd : vertices(sm)){
if(get(vertex_distance,vd) > sdistance){
far = vd;
vfar = vd;
sdistance = get(vertex_distance,vd);
}
}
assert(sdistance > 2.9);
assert(sdistance < CGAL_PI);
hm.add_source(far);
hm.add_source(vfar);
assert(hm.sources().size() == 2);
hm.estimate_geodesic_distances(vertex_distance);
@ -62,7 +62,7 @@ int main(int argc, char* argv[])
assert(sdistance > 1.4);
assert(sdistance < CGAL_PI/2.0);
hm.remove_source(far);
hm.remove_source(vfar);
assert(hm.sources().size() == 1);
hm.clear_sources();
@ -70,7 +70,7 @@ int main(int argc, char* argv[])
// add range of sources
std::vector<vertex_descriptor> vrange;
vrange.push_back(source);
vrange.push_back(far);
vrange.push_back(vfar);
hm.add_sources(vrange);
assert(hm.sources().size() == 2);
hm.estimate_geodesic_distances(vertex_distance);

10
Heat_method_3/test/Heat_method_3/heat_method_surface_mesh_test.cpp
View File

@ -36,19 +36,19 @@ int main(int argc, char* argv[])
Point_3 sp = sm.point(source);
std::cout << "source: " << sp << " " << source << std::endl;
vertex_descriptor far;
vertex_descriptor vfar;
double sdistance = 0;
for(vertex_descriptor vd : vertices(sm)){
if(get(vertex_distance,vd) > sdistance){
far = vd;
vfar = vd;
sdistance = get(vertex_distance,vd);
}
}
assert(sdistance > 2.9);
assert(sdistance < CGAL_PI);
hm.add_source(far);
hm.add_source(vfar);
assert(hm.sources().size() == 2);
hm.estimate_geodesic_distances(vertex_distance);
@ -62,7 +62,7 @@ int main(int argc, char* argv[])
assert(sdistance > 1.4);
assert(sdistance < CGAL_PI/2.0);
hm.remove_source(far);
hm.remove_source(vfar);
assert(hm.sources().size() == 1);
hm.clear_sources();
@ -70,7 +70,7 @@ int main(int argc, char* argv[])
// add range of sources
std::vector<vertex_descriptor> vrange;
vrange.push_back(source);
vrange.push_back(far);
vrange.push_back(vfar);
hm.add_sources(vrange);
assert(hm.sources().size() == 2);
hm.estimate_geodesic_distances(vertex_distance);

2
Hyperbolic_triangulation_2/demo/Hyperbolic_triangulation_2/HDT2.cpp
View File

@ -318,7 +318,7 @@ MainWindow::on_actionInsertRandomPoints_triggered()
tr("Enter number of random points"),
100,
0,
std::numeric_limits<int>::max(),
(std::numeric_limits<int>::max)(),
1,
&ok);

2
Installation/cmake/modules/config/testfiles/CGAL_CFG_NO_LIMITS.cpp
View File

@ -23,7 +23,7 @@
int main()
{
double d = std::numeric_limits<double>::denorm_min();
double e = std::numeric_limits<double>::min();
double e = (std::numeric_limits<double>::min)();
// Note : denorm_min == min is actually not necessarily a bug.
// So a better test should be found.
if (d == 0 || d == e)

2
Kernel_23/include/CGAL/Dimension.h
View File

@ -25,7 +25,7 @@ namespace CGAL {
#ifdef CGAL_EIGEN3_ENABLED
const int UNKNOWN_DIMENSION=Eigen::Dynamic;
#else
const int UNKNOWN_DIMENSION=std::numeric_limits<int>::max();
const int UNKNOWN_DIMENSION=(std::numeric_limits<int>::max)();
#endif
// Check that dimension d1 is fine for a kernel of dimension d2.

8
Kernel_23/include/CGAL/Kernel/hash_functions.h
View File

@ -57,8 +57,8 @@ template <typename K>
inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
hash_value (const Iso_rectangle_2<K>& iso_rectangle)
{
std::size_t result = hash_value(iso_rectangle.min());
boost::hash_combine(result, hash_value(iso_rectangle.max()));
std::size_t result = hash_value((iso_rectangle.min)());
boost::hash_combine(result, hash_value((iso_rectangle.max)()));
return result;
}
@ -126,8 +126,8 @@ template <typename K>
inline std::enable_if_t<std::is_same<typename K::Rep_tag, Cartesian_tag>::value, std::size_t>
hash_value (const Iso_cuboid_3<K>& iso_cuboid)
{
std::size_t result = hash_value(iso_cuboid.min());
boost::hash_combine(result, hash_value(iso_cuboid.max()));
std::size_t result = hash_value((iso_cuboid.min)());
boost::hash_combine(result, hash_value((iso_cuboid.max)()));
return result;
}

4
Kernel_d/test/Kernel_d/Iso_box_d_with_Cartesian.cpp
View File

@ -91,8 +91,8 @@ int main() {
assert(b1.bounded_side(qq1)==CGAL::ON_BOUNDARY);
assert(b1.bounded_side(qq4)==CGAL::ON_UNBOUNDED_SIDE);
assert(b1.bounded_side(mm1)==CGAL::ON_BOUNDED_SIDE);
// std::cout << "b1.min()=" << b1.min() << std::endl;
// std::cout << "b1.max()=" << b1.max() << std::endl;
// std::cout << "(b1.min)()=" << (b1.min)() << std::endl;
// std::cout << "(b1.max)()=" << (b1.max)() << std::endl;
std::cout << "volume of b1=" << b1.volume() << std::endl;
std::cout << "volume of b4=" << b4.volume() << std::endl;
std::cout << "volume of b5=" << b5.volume() << std::endl;

4
Kernel_d/test/Kernel_d/Iso_box_d_with_homogeneous.cpp
View File

@ -94,8 +94,8 @@ int main() {
assert(b1.bounded_side(qq1)==CGAL::ON_BOUNDARY);
assert(b1.bounded_side(qq4)==CGAL::ON_UNBOUNDED_SIDE);
assert(b1.bounded_side(mm1)==CGAL::ON_BOUNDED_SIDE);
// std::cout << "b1.min()=" << b1.min() << std::endl;
// std::cout << "b1.max()=" << b1.max() << std::endl;
// std::cout << "(b1.min)()=" << (b1.min)() << std::endl;
// std::cout << "(b1.max)()=" << (b1.max)() << std::endl;
std::cout << "volume of b1=" << b1.volume() << std::endl;
std::cout << "volume of b4=" << b4.volume() << std::endl;
std::cout << "volume of b5=" << b5.volume() << std::endl;

20
Mesh_3/archive/applications/CGAL/min_dihedral_angle.h
View File

@ -32,15 +32,15 @@ class Compute_min_angle
operator()(const Cell_handle ch) const
{
double min_quotient = compute_quotient(ch, 0, 1, 2, 3);
min_quotient = std::min(min_quotient,
min_quotient = (std::min)(min_quotient,
compute_quotient(ch, 0, 2, 1, 3));
min_quotient = std::min(min_quotient,
min_quotient = (std::min)(min_quotient,
compute_quotient(ch, 0, 3, 1, 2));
min_quotient = std::min(min_quotient,
min_quotient = (std::min)(min_quotient,
compute_quotient(ch, 1, 2, 0, 3));
min_quotient = std::min(min_quotient,
min_quotient = (std::min)(min_quotient,
compute_quotient(ch, 1, 3, 0, 2));
min_quotient = std::min(min_quotient,
min_quotient = (std::min)(min_quotient,
compute_quotient(ch, 2, 3, 0, 1));
const double volume = CGAL::to_double(tr.tetrahedron(ch).volume());
@ -119,19 +119,19 @@ namespace CGAL {
min_dihedral_angle_aux_compute_quotient(p0, p1, p2, p3, k);
min_quotient =
std::min(min_quotient,
(std::min)(min_quotient,
min_dihedral_angle_aux_compute_quotient(p0, p2, p1, p3, k));
min_quotient =
std::min(min_quotient,
(std::min)(min_quotient,
min_dihedral_angle_aux_compute_quotient(p0, p3, p1, p2, k));
min_quotient =
std::min(min_quotient,
(std::min)(min_quotient,
min_dihedral_angle_aux_compute_quotient(p1, p2, p0, p3, k));
min_quotient =
std::min(min_quotient,
(std::min)(min_quotient,
min_dihedral_angle_aux_compute_quotient(p1, p3, p0, p2, k));
min_quotient =
std::min(min_quotient,
(std::min)(min_quotient,
min_dihedral_angle_aux_compute_quotient(p2, p3, p0, p1, k));
// std::cerr << CGAL::sqrt(min_quotient) << " - "

2
Mesh_3/include/CGAL/Mesh_3/Sizing_grid.h
View File

@ -443,7 +443,7 @@ private:
pNode->ref_node(candidate.ref_node());
pNode->size() = candidate.size();
pNode->done() = true;
m_max_size = std::max(m_max_size,pNode->size());
m_max_size = (std::max)(m_max_size,pNode->size());
// explore neighbors
for(unsigned int index_neighbor = 0;

4
Nef_3/archive/Visual_hull/Nef_3/visual_hull_creator.h
View File

@ -87,9 +87,9 @@ class visual_hull_creator : public CGAL::Modifier_base<SNC_> {
public:
visual_hull_creator(Point_3 min, Point_3 max, Point_3 position,
visual_hull_creator(Point_3 pmin, Point_3 pmax, Point_3 position,
std::list<std::list<Point_3> > p) :
room_min(min), room_max(max), c_pos(position), polygon_list(p) { }
room_min(pmin), room_max(pmax), c_pos(position), polygon_list(p) { }
/*
void recompute_scene() {

18
Nef_3/include/CGAL/Nef_3/Infimaximal_box.h
View File

@ -375,24 +375,24 @@ class Infimaximal_box<Tag_true, Kernel> {
C.create_vertices_of_box_with_plane(h, b);
}
static void compute_min_max(const Plane_3& h, NT orth_coords[3], int& min, int& max) {
static void compute_min_max(const Plane_3& h, NT orth_coords[3], int& cmin, int& cmax) {
Vector_3 orth = h.orthogonal_vector();
orth_coords[0] = CGAL_NTS abs(orth.hx()[0]);
orth_coords[1] = CGAL_NTS abs(orth.hy()[0]);
orth_coords[2] = CGAL_NTS abs(orth.hz()[0]);
max = 0;
cmax = 0;
if(orth_coords[1] > orth_coords[0])
max = 1;
if(orth_coords[2] > orth_coords[max])
max = 2;
cmax = 1;
if(orth_coords[2] > orth_coords[cmax])
cmax = 2;
min = 0;
cmin = 0;
if(orth_coords[1] < orth_coords[0])
min = 1;
if(orth_coords[2] < orth_coords[min])
min = 2;
cmin = 1;
if(orth_coords[2] < orth_coords[cmin])
cmin = 2;
}
template<typename SNC_structure>

2
Number_types/include/CGAL/Quotient.h
View File

@ -142,7 +142,7 @@ class Quotient
}
#ifdef CGAL_ROOT_OF_2_ENABLE_HISTOGRAM_OF_NUMBER_OF_DIGIT_ON_THE_COMPLEX_CONSTRUCTOR
int tam() const { return std::max(num.tam(), den.tam()); }
int tam() const { return (std::max)(num.tam(), den.tam()); }
#endif
public:

4
Optimal_bounding_box/include/CGAL/Optimal_bounding_box/internal/fitness_function.h
View File

@ -39,7 +39,7 @@ compute_fitness(const typename Traits::Matrix& R, // rotation matrix
CGAL_assertion(points.size() >= 3);
FT xmin, ymin, zmin, xmax, ymax, zmax;
xmin = ymin = zmin = FT{std::numeric_limits<double>::max()};
xmin = ymin = zmin = FT{(std::numeric_limits<double>::max)()};
xmax = ymax = zmax = FT{std::numeric_limits<double>::lowest()};
for(const Point& pt : points)
@ -81,7 +81,7 @@ compute_fitness_if_smaller(const typename Traits::Matrix& R, // rotation matrix
CGAL_assertion(points.size() >= 3);
FT xmin, ymin, zmin, xmax, ymax, zmax;
xmin = ymin = zmin = FT{std::numeric_limits<double>::max()};
xmin = ymin = zmin = FT{(std::numeric_limits<double>::max)()};
xmax = ymax = zmax = FT{std::numeric_limits<double>::lowest()};
// compute every 1%, with a minimum of 1000 iterations

2
Optimal_bounding_box/include/CGAL/Optimal_bounding_box/internal/optimize_2.h
View File

@ -123,7 +123,7 @@ void optimize_along_OBB_axes(typename Traits::Matrix& rot,
rotated_points.reserve(points.size());
FT xmin, ymin, zmin, xmax, ymax, zmax;
xmin = ymin = zmin = FT{std::numeric_limits<double>::max()};
xmin = ymin = zmin = FT{(std::numeric_limits<double>::max)()};
xmax = ymax = zmax = FT{std::numeric_limits<double>::lowest()};
for(const Point& pt : points)

2
Optimal_bounding_box/include/CGAL/Optimal_bounding_box/internal/population.h
View File

@ -121,7 +121,7 @@ public:
Vertex& get_best_vertex()
{
std::size_t simplex_id = static_cast<std::size_t>(-1), vertex_id = static_cast<std::size_t>(-1);
FT best_fitness = FT{std::numeric_limits<double>::max()};
FT best_fitness = FT{(std::numeric_limits<double>::max)()};
for(std::size_t i=0, ps=m_simplices.size(); i<ps; ++i)
{
for(std::size_t j=0; j<4; ++j)

2
Optimal_bounding_box/test/Optimal_bounding_box/test_optimization_algorithms.cpp
View File

@ -29,7 +29,7 @@ bool is_equal(const FT d1, const FT d2)
bool ok;
if(std::is_floating_point<FT>::value)
ok = CGAL::abs(d1 - d2) < std::max(epsilon * d1, epsilon);
ok = CGAL::abs(d1 - d2) < (std::max)(epsilon * d1, epsilon);
else
ok = (d1 == d2);

4
Periodic_2_triangulation_2/include/CGAL/draw_periodic_2_triangulation_2.h
View File

@ -129,10 +129,10 @@ protected:
for(int j = 0; j < covering_sheets[1]; j++){
Kernel::Vector_2 shift(i * (orig_domain.xmax() - orig_domain.xmin()),
j * orig_domain.ymax() - orig_domain.ymin());
Kernel::Point_2 p1(orig_domain.min());
Kernel::Point_2 p1((orig_domain.min)());
Kernel::Point_2 p2(orig_domain.xmin(), orig_domain.ymax());
Kernel::Point_2 p3(orig_domain.xmax(), orig_domain.ymin());
Kernel::Point_2 p4(orig_domain.max());
Kernel::Point_2 p4((orig_domain.max)());
add_segment(p1 + shift, p2 + shift, CGAL::Color(96, 104, 252));
add_segment(p1 + shift, p3 + shift, CGAL::Color(96, 104, 252));

12
Periodic_3_mesh_3/include/CGAL/Periodic_3_mesh_3/IO/File_medit.h
View File

@ -43,9 +43,9 @@ canonicalize_triangle(const typename Triangulation::Periodic_triangle& pt)
Offset o0 = pt[0].second;
Offset o1 = pt[1].second;
Offset o2 = pt[2].second;
int diffx = std::min(o0.x(), std::min(o1.x(), o2.x()));
int diffy = std::min(o0.y(), std::min(o1.y(), o2.y()));
int diffz = std::min(o0.z(), std::min(o1.z(), o2.z()));
int diffx = (std::min)(o0.x(), (std::min)(o1.x(), o2.x()));
int diffy = (std::min)(o0.y(), (std::min)(o1.y(), o2.y()));
int diffz = (std::min)(o0.z(), (std::min)(o1.z(), o2.z()));
Offset diff_off(diffx, diffy, diffz);
return CGAL::make_array(std::make_pair(pt[0].first, o0 - diff_off),
@ -64,9 +64,9 @@ canonicalize_tetrahedron(const typename Triangulation::Periodic_tetrahedron& pt)
Offset o2 = pt[2].second;
Offset o3 = pt[3].second;
int diffx = std::min(std::min(o0.x(), o1.x()), std::min(o2.x(), o3.x()));
int diffy = std::min(std::min(o0.y(), o1.y()), std::min(o2.y(), o3.y()));
int diffz = std::min(std::min(o0.z(), o1.z()), std::min(o2.z(), o3.z()));
int diffx = (std::min)((std::min)(o0.x(), o1.x()), (std::min)(o2.x(), o3.x()));
int diffy = (std::min)((std::min)(o0.y(), o1.y()), (std::min)(o2.y(), o3.y()));
int diffz = (std::min)((std::min)(o0.z(), o1.z()), (std::min)(o2.z(), o3.z()));
Offset diff_off(diffx, diffy, diffz);
return CGAL::make_array(std::make_pair(pt[0].first, o0 - diff_off),

22
Periodic_3_mesh_3/test/Periodic_3_mesh_3/test_triply_periodic_minimal_surfaces.cpp
View File

@ -184,18 +184,18 @@ struct Segments_function
Segments_function()
: segments(), nb_evals(0)
{
const FT min = 1, max = 3;
const FT mid = 0.5 * (min + max);
const FT vmin = 1, vmax = 3;
const FT mid = 0.5 * (vmin + vmax);
const Point pmid(mid, mid, mid);
segments.push_back(Segment(Point(min, mid, min), pmid));
segments.push_back(Segment(Point(max, mid, min), pmid));
segments.push_back(Segment(Point(min, mid, max), pmid));
segments.push_back(Segment(Point(max, mid, max), pmid));
segments.push_back(Segment(Point(mid, min, min), pmid));
segments.push_back(Segment(Point(mid, max, min), pmid));
segments.push_back(Segment(Point(mid, min, max), pmid));
segments.push_back(Segment(Point(mid, max, max), pmid));
segments.push_back(Segment(Point(vmin, mid, vmin), pmid));
segments.push_back(Segment(Point(vmax, mid, vmin), pmid));
segments.push_back(Segment(Point(vmin, mid, vmax), pmid));
segments.push_back(Segment(Point(vmax, mid, vmax), pmid));
segments.push_back(Segment(Point(mid, vmin, vmin), pmid));
segments.push_back(Segment(Point(mid, vmax, vmin), pmid));
segments.push_back(Segment(Point(mid, vmin, vmax), pmid));
segments.push_back(Segment(Point(mid, vmax, vmax), pmid));
}
FT operator()(const Point& p)
@ -204,7 +204,7 @@ struct Segments_function
FT min_distance = 1000000;
for (Segments::const_iterator si = segments.begin(); si != segments.end(); ++si)
min_distance = std::min(CGAL::squared_distance(p, *si), min_distance);
min_distance = (std::min)(CGAL::squared_distance(p, *si), min_distance);
return min_distance - 0.01; // Change the squared beam radius here
}

12
Periodic_3_triangulation_3/test/Periodic_3_triangulation_3/include/CGAL/_test_periodic_3_static_filters.h
View File

@ -61,17 +61,17 @@ Point my_rand_p3()
}
// Random int in [0;256).
int my_rand_int(int min, int max)
int my_rand_int(int imin, int imax)
{
return r->get_int(min, max+1);
return r->get_int(imin, imax+1);
}
// Random offset
Offset my_rand_o3(int min, int max)
Offset my_rand_o3(int imin, int imax)
{
int x = my_rand_int(min,max);
int y = my_rand_int(min,max);
int z = my_rand_int(min,max);
int x = my_rand_int(imin,imax);
int y = my_rand_int(imin,imax);
int z = my_rand_int(imin,imax);
return Offset(x, y, z);
}

2
Periodic_4_hyperbolic_triangulation_2/demo/Periodic_4_hyperbolic_triangulation_2/P4HDT2.cpp
View File

@ -351,7 +351,7 @@ MainWindow::on_actionInsertRandomPoints_triggered()
tr("Enter number of random points"),
100,
0,
std::numeric_limits<int>::max(),
(std::numeric_limits<int>::max)(),
1,
&ok);

6
Periodic_4_hyperbolic_triangulation_2/include/CGAL/Periodic_4_hyperbolic_triangulation_2.h
View File

@ -608,15 +608,15 @@ protected:
}
// Now we know that all vertices lie in different regions.
Hyperbolic_translation min(7, 2, 5);
Hyperbolic_translation vmin(7, 2, 5);
Hyperbolic_translation trans;
for(int i=0; i<3; ++i)
{
int j = (i + 1) % 3; // the index of the 'next' vertex
Hyperbolic_translation tmp = fh->translation(i).inverse() * fh->translation(j);
if(tmp < min)
if(tmp < vmin)
{
min = tmp;
vmin = tmp;
trans = fh->translation(i).inverse();
}
}

6
Polygon_mesh_processing/benchmark/Polygon_mesh_processing/polygon_mesh_slicer.cpp
View File

@ -106,9 +106,9 @@ int main(int argc, char* argv[])
t.start();
std::cerr << "bbox"<< std::endl;
Iso_cuboid_3 ic = CGAL::bounding_box(points(m).begin(), points(m).end());
Point_3 p = midpoint(ic.min(), ic.max());
double zmin = ic.min().z();
double zmax = ic.max().z();
Point_3 p = midpoint((ic.min)(), (ic.max)());
double zmin = (ic.min)().z();
double zmax = (ic.max)().z();
double delta = (zmax - zmin)/N;
std::cerr << "slicer"<< std::endl;

12
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/AABB_traversal_traits_with_transformation.h
View File

@ -51,9 +51,9 @@ class Traversal_traits_with_transformation_helper
AK::Aff_transformation_3 a_at = c2f(at);
AK::FT xtrm[6] = { c2f(bbox.min(0)), c2f(bbox.max(0)),
c2f(bbox.min(1)), c2f(bbox.max(1)),
c2f(bbox.min(2)), c2f(bbox.max(2)) };
AK::FT xtrm[6] = { c2f((bbox.min)(0)), c2f((bbox.max)(0)),
c2f((bbox.min)(1)), c2f((bbox.max)(1)),
c2f((bbox.min)(2)), c2f((bbox.max)(2)) };
typename AK::Point_3 ps[8];
ps[0] = a_at( AK::Point_3(xtrm[0], xtrm[2], xtrm[4]) );
@ -83,9 +83,9 @@ class Traversal_traits_with_transformation_helper
AK::Aff_transformation_3 a_at = c2f(at);
AK::FT xtrm[6] = { c2f(bbox.min(0)), c2f(bbox.max(0)),
c2f(bbox.min(1)), c2f(bbox.max(1)),
c2f(bbox.min(2)), c2f(bbox.max(2)) };
AK::FT xtrm[6] = { c2f((bbox.min)(0)), c2f((bbox.max)(0)),
c2f((bbox.min)(1)), c2f((bbox.max)(1)),
c2f((bbox.min)(2)), c2f((bbox.max)(2)) };
typename AK::Point_3 ps[2];
ps[0] = a_at( AK::Point_3(xtrm[0], xtrm[2], xtrm[4]) );

4
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Snapping/snap.h
View File

@ -1216,7 +1216,7 @@ std::size_t snap_borders(TriangleMesh& tm_A,
border_halfedges(tm_A, std::back_inserter(border_vertices_A));
border_halfedges(tm_B, std::back_inserter(border_vertices_B));
const FT tol_mx(std::numeric_limits<double>::max());
const FT tol_mx((std::numeric_limits<double>::max)());
Tolerance_map tolerance_map_A = get(Vertex_property_tag(), tm_A);
internal::assign_tolerance_with_local_edge_length_bound(border_vertices_A, tolerance_map_A, tol_mx, tm_A, np_A);
Tolerance_map tolerance_map_B = get(Vertex_property_tag(), tm_B);
@ -1296,7 +1296,7 @@ std::size_t snap_borders(TriangleMesh& tm,
std::vector<halfedge_descriptor> border_vertices;
border_halfedges(tm, std::back_inserter(border_vertices));
const FT tol_mx(std::numeric_limits<double>::max());
const FT tol_mx((std::numeric_limits<double>::max)());
Tolerance_map tolerance_map = get(Vertex_property_tag(), tm);
internal::assign_tolerance_with_local_edge_length_bound(border_vertices, tolerance_map, tol_mx, tm, np);

2
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Snapping/snap_vertices.h
View File

@ -868,7 +868,7 @@ std::size_t snap_vertices(const HalfedgeRange_A& halfedge_range_A,
typedef CGAL::dynamic_vertex_property_t<FT> Vertex_property_tag;
typedef typename boost::property_map<PolygonMesh, Vertex_property_tag>::type Tolerance_map;
const FT max_tol(std::numeric_limits<double>::max());
const FT max_tol((std::numeric_limits<double>::max)());
Tolerance_map tolerance_map_A = get(Vertex_property_tag(), tm_A);
internal::assign_tolerance_with_local_edge_length_bound(halfedge_range_A, tolerance_map_A, max_tol, tm_A, np_A);

38
Polygon_mesh_processing/test/Polygon_mesh_processing/test_repair_polygon_soup.cpp
View File

@ -19,7 +19,7 @@ typedef CGAL::Exact_predicates_inexact_constructions_kernel K;
typedef K::Point_3 Point_3;
typedef CGAL::Surface_mesh<Point_3> Mesh;
typedef std::vector<std::size_t> Polygon;
typedef std::vector<std::size_t> CGAL_polygon;
void test_polygon_canonicalization(const bool verbose = false)
{
@ -34,8 +34,8 @@ void test_polygon_canonicalization(const bool verbose = false)
points.push_back(Point_3(1,1,-2)); // #5
// empty
Polygon polygon;
Polygon canonical_polygon = PMP::internal::construct_canonical_polygon(points, polygon, K());
CGAL_polygon polygon;
CGAL_polygon canonical_polygon = PMP::internal::construct_canonical_polygon(points, polygon, K());
assert(canonical_polygon.empty());
// 1 point
@ -76,7 +76,7 @@ void test_polygon_canonicalization(const bool verbose = false)
// all cyclic permutations
for(std::size_t i=0, end=polygon.size(); i<end; ++i)
{
Polygon cpol = PMP::internal::construct_canonical_polygon(points, polygon, K());
CGAL_polygon cpol = PMP::internal::construct_canonical_polygon(points, polygon, K());
if(verbose)
{
std::cout << "Input polygon:";
@ -93,7 +93,7 @@ void test_polygon_canonicalization(const bool verbose = false)
std::reverse(polygon.begin(), polygon.end());
for(std::size_t i=0, end=polygon.size(); i<end; ++i)
{
Polygon cpol = PMP::internal::construct_canonical_polygon(points, polygon, K());
CGAL_polygon cpol = PMP::internal::construct_canonical_polygon(points, polygon, K());
if(verbose)
{
std::cout << "Input polygon:";
@ -112,7 +112,7 @@ void test_merge_duplicate_points(const bool /*verbose*/ = false)
std::cout << "test merge duplicate points... " << std::endl;
std::vector<Point_3> points;
std::vector<Polygon> polygons;
std::vector<CGAL_polygon> polygons;
// empty
std::size_t res = PMP::merge_duplicate_points_in_polygon_soup(points, polygons);
@ -126,7 +126,7 @@ void test_merge_duplicate_points(const bool /*verbose*/ = false)
points.push_back(Point_3(1,1,0)); // #5 // identical to #2
points.push_back(Point_3(0,0,0)); // #6 // idental to #0
Polygon polygon;
CGAL_polygon polygon;
polygon.push_back(0); polygon.push_back(1); polygon.push_back(2);
polygons.push_back(polygon);
@ -146,7 +146,7 @@ void test_merge_duplicate_points(const bool /*verbose*/ = false)
for(std::size_t i=0, psn=polygons.size(); i<psn; ++i)
{
const Polygon& polygon = polygons[i];
const CGAL_polygon& polygon = polygons[i];
for(std::size_t j=0, pn=polygon.size(); j<pn; ++j)
{
assert(polygon[j] < points.size());
@ -159,7 +159,7 @@ void test_merge_duplicate_polygons(const bool /*verbose*/ = false)
std::cout << "test duplicate polygons merging..." << std::endl;
std::vector<Point_3> points;
std::vector<Polygon> polygons;
std::vector<CGAL_polygon> polygons;
points.push_back(Point_3(0,0,0)); // #0
points.push_back(Point_3(1,0,0)); // #1
@ -180,7 +180,7 @@ void test_merge_duplicate_polygons(const bool /*verbose*/ = false)
// -------------------------------------------------------
// 1 polygon
Polygon polygon;
CGAL_polygon polygon;
polygon.push_back(0); polygon.push_back(1); polygon.push_back(2);
polygons.push_back(polygon);
@ -257,7 +257,7 @@ void test_merge_duplicate_polygons(const bool /*verbose*/ = false)
assert(all_duplicate_polygons[0].size() == 2 && all_duplicate_polygons[1].size() == 3);
// Keep one for each duplicate
std::vector<Polygon> polygons_copy(polygons);
std::vector<CGAL_polygon> polygons_copy(polygons);
res = PMP::merge_duplicate_polygons_in_polygon_soup(points, polygons_copy,
params::all_default());
assert(res == 3 && polygons_copy.size() == 3);
@ -281,7 +281,7 @@ void test_simplify_polygons(const bool /*verbose*/ = false)
std::cout << "test simplify_polygons... " << std::endl;
std::vector<Point_3> points;
std::vector<Polygon> polygons;
std::vector<CGAL_polygon> polygons;
points.push_back(Point_3(0,0,0)); // #0
points.push_back(Point_3(1,2,0)); // #1
@ -292,7 +292,7 @@ void test_simplify_polygons(const bool /*verbose*/ = false)
points.push_back(Point_3(0,0,0)); // #6
// ------
Polygon polygon;
CGAL_polygon polygon;
polygon.push_back(0); polygon.push_back(2); polygon.push_back(4);
polygons.push_back(polygon);
@ -355,13 +355,13 @@ void test_remove_invalid_polygons(const bool /*verbose*/ = false)
// points are not actually needed since only the size of the polygons is considered
std::vector<Point_3> points;
std::vector<Polygon> polygons;
std::vector<CGAL_polygon> polygons;
std::size_t res = PMP::internal::remove_invalid_polygons_in_polygon_soup(points, polygons);
assert(res == 0 && polygons.size() == 0);
// non-trivial polygon
Polygon polygon;
CGAL_polygon polygon;
polygon.push_back(0); polygon.push_back(2); polygon.push_back(4);
polygons.push_back(polygon);
@ -431,7 +431,7 @@ void test_remove_isolated_points(const bool verbose = false)
std::cout << "test remove_isolated_points... " << std::endl;
std::vector<Point_3> points;
std::vector<Polygon> polygons;
std::vector<CGAL_polygon> polygons;
// everything empty
std::size_t res = test_remove_isolated_points_data_set(points, polygons, verbose);
@ -449,7 +449,7 @@ void test_remove_isolated_points(const bool verbose = false)
res = test_remove_isolated_points_data_set(points_copy, polygons, verbose);
assert(res == 6 && points_copy.empty() && polygons.empty());
Polygon polygon;
CGAL_polygon polygon;
polygon.push_back(0); polygon.push_back(2); polygon.push_back(4);
polygons.push_back(polygon);
@ -467,7 +467,7 @@ void test_slit_pinched_polygons(const bool /*verbose*/ = false)
std::cout << "test split_pinched_polygons... " << std::endl;
std::vector<Point_3> points;
std::vector<Polygon> polygons;
std::vector<CGAL_polygon> polygons;
// everything empty
std::size_t res = PMP::internal::split_pinched_polygons_in_polygon_soup<K>(points, polygons);
@ -481,7 +481,7 @@ void test_slit_pinched_polygons(const bool /*verbose*/ = false)
points.push_back(Point_3(1,1,0)); // #5
// no pinch
Polygon polygon;
CGAL_polygon polygon;
polygon.push_back(0); polygon.push_back(2); polygon.push_back(4);
polygons.push_back(polygon);

4
Polygonal_surface_reconstruction/include/CGAL/internal/hypothesis.h
View File

@ -374,12 +374,12 @@ namespace CGAL {
Planar_segment* s = segments[i];
const Plane* plane = s->fit_supporting_plane(); // user may provide invalid plane fitting (we always fit)
FT max_dist = -std::numeric_limits<FT>::max();
FT max_dist = -(std::numeric_limits<FT>::max)();
for (std::size_t j = 0; j < s->size(); ++j) {
std::size_t idx = s->at(j);
const Point& p = points[idx];
FT sdist = CGAL::squared_distance(*plane, p);
max_dist = std::max(max_dist, std::sqrt(sdist));
max_dist = (std::max)(max_dist, std::sqrt(sdist));
}
avg_max_dist += max_dist;

4
Polyhedron/demo/Polyhedron/CGAL_double_edit.cpp
View File

@ -57,9 +57,9 @@ public:
this->validator->setTop(d);
}
void DoubleEdit::setRange(double min, double max)
void DoubleEdit::setRange(double rmin, double rmax)
{
this->validator->setRange(min, max, this->validator->decimals());
this->validator->setRange(rmin, rmax, this->validator->decimals());
}
double DoubleEdit::getValue()

2
Polyhedron/demo/Polyhedron/CGAL_double_edit.h
View File

@ -23,7 +23,7 @@ public:
void setValue(double d);
void setMinimum(double d);
void setMaximum(double d);
void setRange(double min, double max);
void setRange(double rmin, double rmax);
double getValue();
double getMinimum();
double getMaximum();

6
Polyhedron/demo/Polyhedron/MainWindow.cpp
View File

@ -1006,7 +1006,7 @@ void MainWindow::updateViewersBboxes(bool recenter)
}
void MainWindow::computeViewerBBox(CGAL::qglviewer::Vec& min, CGAL::qglviewer::Vec& max)
void MainWindow::computeViewerBBox(CGAL::qglviewer::Vec& vmin, CGAL::qglviewer::Vec& vmax)
{
const Scene::Bbox bbox = scene->bbox();
const double xmin = bbox.xmin();
@ -1018,8 +1018,8 @@ void MainWindow::computeViewerBBox(CGAL::qglviewer::Vec& min, CGAL::qglviewer::V
min = CGAL::qglviewer::Vec(xmin, ymin, zmin);
max= CGAL::qglviewer::Vec(xmax, ymax, zmax);
vmin = CGAL::qglviewer::Vec(xmin, ymin, zmin);
vmax= CGAL::qglviewer::Vec(xmax, ymax, zmax);
CGAL::qglviewer::Vec bbox_center((xmin+xmax)/2, (ymin+ymax)/2, (zmin+zmax)/2);

2
Polyhedron/demo/Polyhedron/MainWindow.h
View File

@ -95,7 +95,7 @@ public:
CGAL::Three::Polyhedron_demo_io_plugin_interface*,
bool& ok,
bool add_to_scene=true);
void computeViewerBBox(CGAL::qglviewer::Vec &min, CGAL::qglviewer::Vec &max);
void computeViewerBBox(CGAL::qglviewer::Vec &vmin, CGAL::qglviewer::Vec &vmax);
void updateViewerBbox(Viewer* vi, bool recenter, CGAL::qglviewer::Vec min,
CGAL::qglviewer::Vec max);
Q_SIGNALS:

6
Polyhedron/demo/Polyhedron/Plugins/AABB_tree/Do_trees_intersect_plugin.cpp
View File

@ -102,9 +102,9 @@ private Q_SLOTS:
connect(item, &Scene_surface_mesh_item::aboutToBeDestroyed,
this, &DoTreesIntersectplugin::cleanup);
CGAL::qglviewer::Vec pos((item->bbox().min(0) + item->bbox().max(0))/2.0,
(item->bbox().min(1) + item->bbox().max(1))/2.0,
(item->bbox().min(2) + item->bbox().max(2))/2.0);
CGAL::qglviewer::Vec pos(((item->bbox().min)(0) + (item->bbox().max)(0))/2.0,
((item->bbox().min)(1) + (item->bbox().max)(1))/2.0,
((item->bbox().min)(2) + (item->bbox().max)(2))/2.0);
Scene_movable_sm_item* mov_item = new Scene_movable_sm_item(pos,item->face_graph(),"");
connect(mov_item->manipulatedFrame(), &CGAL::qglviewer::ManipulatedFrame::modified,

6
Polyhedron/demo/Polyhedron/Plugins/Classification/Cluster_classification.cpp
View File

@ -527,7 +527,7 @@ void Cluster_classification::change_color (int index, float* vmin, float* vmax)
int cid = m_cluster_id[*it];
if (cid != -1)
{
float v = std::max (0.f, std::min(1.f, m_label_probabilities[corrected_index][cid]));
float v = std::max (0.f, (std::min)(1.f, m_label_probabilities[corrected_index][cid]));
m_points->point_set()->set_color(*it, ramp.r(v) * 255, ramp.g(v) * 255, ramp.b(v) * 255);
}
else
@ -546,8 +546,8 @@ void Cluster_classification::change_color (int index, float* vmin, float* vmax)
Feature_handle feature = m_features[corrected_index];
float min = std::numeric_limits<float>::max();
float max = -std::numeric_limits<float>::max();
float min = (std::numeric_limits<float>::max)();
float max = -(std::numeric_limits<float>::max)();
if (vmin != NULL && vmax != NULL
&& *vmin != std::numeric_limits<float>::infinity()

6
Polyhedron/demo/Polyhedron/Plugins/Classification/Point_set_item_classification.cpp
View File

@ -429,7 +429,7 @@ void Point_set_item_classification::change_color (int index, float* vmin, float*
for (Point_set::const_iterator it = m_points->point_set()->begin();
it != m_points->point_set()->first_selected(); ++ it)
{
float v = std::max (0.f, std::min(1.f, m_label_probabilities[corrected_index][*it]));
float v = (std::max)(0.f, (std::min)(1.f, m_label_probabilities[corrected_index][*it]));
m_points->point_set()->set_color(*it, ramp.r(v) * 255, ramp.g(v) * 255, ramp.b(v) * 255);
}
}
@ -444,8 +444,8 @@ void Point_set_item_classification::change_color (int index, float* vmin, float*
}
Feature_handle feature = m_features[corrected_index];
float min = std::numeric_limits<float>::max();
float max = -std::numeric_limits<float>::max();
float min = (std::numeric_limits<float>::max)();
float max = -(std::numeric_limits<float>::max)();
if (vmin != NULL && vmax != NULL
&& *vmin != std::numeric_limits<float>::infinity()

4
Polyhedron/demo/Polyhedron/Plugins/Classification/Point_set_item_classification.h
View File

@ -118,8 +118,8 @@ class Point_set_item_classification : public Item_classification_base
for (std::size_t i = 0; i < m_features.size(); ++ i)
{
float vmin = std::numeric_limits<float>::max();
float vmax = -std::numeric_limits<float>::max();
float vmin = (std::numeric_limits<float>::max)();
float vmax = -(std::numeric_limits<float>::max)();
float vmean = 0.f;
std::size_t nb = 0;

6
Polyhedron/demo/Polyhedron/Plugins/Classification/Surface_mesh_item_classification.cpp
View File

@ -151,7 +151,7 @@ void Surface_mesh_item_classification::change_color (int index, float* vmin, flo
{
for(face_descriptor fd : faces(*(m_mesh->polyhedron())))
{
float v = std::max (0.f, std::min(1.f, m_label_probabilities[corrected_index][fd]));
float v = std::max (0.f, (std::min)(1.f, m_label_probabilities[corrected_index][fd]));
m_color[fd] = CGAL::Color((unsigned char)(ramp.r(v) * 255),
(unsigned char)(ramp.g(v) * 255),
(unsigned char)(ramp.b(v) * 255));
@ -169,8 +169,8 @@ void Surface_mesh_item_classification::change_color (int index, float* vmin, flo
Feature_handle feature = m_features[corrected_index];
float min = std::numeric_limits<float>::max();
float max = -std::numeric_limits<float>::max();
float min = (std::numeric_limits<float>::max)();
float max = -(std::numeric_limits<float>::max)();
if (vmin != NULL && vmax != NULL
&& *vmin != std::numeric_limits<float>::infinity()

12
Polyhedron/demo/Polyhedron/Plugins/PCA/Affine_transform_plugin.cpp
View File

@ -417,12 +417,12 @@ void Polyhedron_demo_affine_transform_plugin::grid()
Scene_item::Bbox b = item->bbox();
double x_t(CGAL::sqrt(CGAL::squared_distance(Kernel::Point_3(b.min(0), b.min(1), b.min(2)),
Kernel::Point_3(b.max(0), b.min(1), b.min(2))))),
y_t(CGAL::sqrt(CGAL::squared_distance(Kernel::Point_3(b.min(0), b.min(1), b.min(2)),
Kernel::Point_3(b.min(0), b.max(1), b.min(2))))),
z_t(CGAL::sqrt(CGAL::squared_distance(Kernel::Point_3(b.min(0), b.min(1), b.min(2)),
Kernel::Point_3(b.min(0), b.min(1), b.max(2)))));
double x_t(CGAL::sqrt(CGAL::squared_distance(Kernel::Point_3((b.min)(0), (b.min)(1), (b.min)(2)),
Kernel::Point_3((b.max)(0), (b.min)(1), (b.min)(2))))),
y_t(CGAL::sqrt(CGAL::squared_distance(Kernel::Point_3((b.min)(0), (b.min)(1), (b.min)(2)),
Kernel::Point_3((b.min)(0), (b.max)(1), (b.min)(2))))),
z_t(CGAL::sqrt(CGAL::squared_distance(Kernel::Point_3((b.min)(0), (b.min)(1), (b.min)(2)),
Kernel::Point_3((b.min)(0), (b.min)(1), (b.max)(2)))));
GridDialog dialog(mw);
dialog.x_space_doubleSpinBox->setValue(x_t);

6
Polyhedron/demo/Polyhedron/Plugins/PCA/Create_bbox_mesh_plugin.cpp
View File

@ -116,9 +116,9 @@ bool Create_bbox_mesh_plugin::bbox(bool extended)
bbox.zmax() + delta_z);
}
if(bbox.min(0) > bbox.max(0) ||
bbox.min(1) > bbox.max(1) ||
bbox.min(2) > bbox.max(2))
if((bbox.min)(0) > (bbox.max)(0) ||
(bbox.min)(1) > (bbox.max)(1) ||
(bbox.min)(2) > (bbox.max)(2))
{
return false;
}

10
Polyhedron/demo/Polyhedron/Plugins/PCA/Scene_edit_box_item.cpp
View File

@ -392,16 +392,16 @@ void Scene_edit_box_item::compute_bbox() const
const CGAL::qglviewer::Vec offset = static_cast<CGAL::Three::Viewer_interface*>(CGAL::QGLViewer::QGLViewerPool().first())->offset();
QVector3D min(d->pool[0], d->pool[1], d->pool[2]);
QVector3D max(d->pool[3], d->pool[4], d->pool[5]);
QVector3D vmin(d->pool[0], d->pool[1], d->pool[2]);
QVector3D vmax(d->pool[3], d->pool[4], d->pool[5]);
for(int i=0; i< 3; ++i)
{
min[i] += d->frame->translation()[i]-d->center_[i]-offset[i];
max[i] += d->frame->translation()[i]-d->center_[i]-offset[i];
vmin[i] += d->frame->translation()[i]-d->center_[i]-offset[i];
vmax[i] += d->frame->translation()[i]-d->center_[i]-offset[i];
}
setBbox(Scene_item::Bbox(min.x(),min.y(),min.z(),max.x(),max.y(),max.z()));
setBbox(Scene_item::Bbox(vmin.x(),vmin.y(),vmin.z(),vmax.x(),vmax.y(),vmax.z()));
}

8
Polyhedron/demo/Polyhedron/Plugins/PCA/Scene_facegraph_transform_item.cpp
View File

@ -123,10 +123,10 @@ Scene_facegraph_transform_item::compute_bbox() const {
++it) {
bbox = bbox + get(vpmap, *it).bbox();
}
CGAL::qglviewer::Vec min(bbox.xmin(),bbox.ymin(),bbox.zmin());
CGAL::qglviewer::Vec max(bbox.xmax(),bbox.ymax(),bbox.zmax());
setBbox(Bbox(min.x,min.y,min.z,
max.x,max.y,max.z));
CGAL::qglviewer::Vec vmin(bbox.xmin(),bbox.ymin(),bbox.zmin());
CGAL::qglviewer::Vec vmax(bbox.xmax(),bbox.ymax(),bbox.zmax());
setBbox(Bbox(vmin.x,vmin.y,vmin.z,
vmax.x,vmax.y,vmax.z));
}

8
Polyhedron/demo/Polyhedron/Plugins/PMP/Engrave_text_plugin.cpp
View File

@ -490,10 +490,10 @@ public Q_SLOTS:
}
std::cout << "Parameterized with ARAP (SM) computed." << std::endl;
xmin = std::numeric_limits<double>::max();
xmax = std::numeric_limits<double>::min();
ymin = std::numeric_limits<double>::max();
ymax = std::numeric_limits<double>::min();
xmin = (std::numeric_limits<double>::max)();
xmax = (std::numeric_limits<double>::min)();
ymin = (std::numeric_limits<double>::max)();
ymax = (std::numeric_limits<double>::min)();
uv_map_3 =
sm->add_property_map<SMesh::Vertex_index, Point_3>("v:uv3").first;
for(SMesh::Vertex_index v : sm->vertices())

2
Polyhedron/demo/Polyhedron/Plugins/Surface_mesh/Mesh_segmentation_plugin.cpp
View File

@ -307,7 +307,7 @@ void Polyhedron_demo_mesh_segmentation_plugin::apply_Partition_button_clicked(Fa
faces(*pair->first->face_graph()))
{
if(sdf_pmap[f] != -1
&& sdf_pmap[f] != std::numeric_limits<double>::max())
&& sdf_pmap[f] != (std::numeric_limits<double>::max)())
{
has_sdf_values = true;
break;

2
Polyhedron/demo/Polyhedron/Plugins/Surface_mesh/Mesh_simplification_plugin.cpp
View File

@ -149,7 +149,7 @@ void Polyhedron_demo_mesh_simplification_plugin::on_actionSimplify_triggered()
: 0),
(ui.m_use_edge_length->isChecked()
? ui.m_edge_length->value()
: std::numeric_limits<double>::max()));
: (std::numeric_limits<double>::max)()));
if (selection_item)
{

6
Polyhedron/demo/Polyhedron/Plugins/Surface_mesh/Offset_meshing_plugin.cpp
View File

@ -436,9 +436,9 @@ void Polyhedron_demo_offset_meshing_plugin::offset_meshing()
}
else if(soup_item == 0)
return;
double X=box.max(0)-box.min(0),
Y = box.max(1)-box.min(1),
Z = box.max(2)-box.min(2);
double X=(box.max)(0)-(box.min)(0),
Y = (box.max)(1)-(box.min)(1),
Z = (box.max)(2)-(box.min)(2);
diag = CGAL::sqrt(X*X+Y*Y+Z*Z);
double offset_value = QInputDialog::getDouble(mw,
QString("Choose Offset Value"),

20
Polyhedron/demo/Polyhedron/Plugins/Surface_mesh/Parameterization_plugin.cpp
View File

@ -907,7 +907,7 @@ void Polyhedron_demo_parameterization_plugin::parameterize(const Parameterizatio
} //end for each component
QApplication::restoreOverrideCursor();
QPointF min(FLT_MAX, FLT_MAX), max(-FLT_MAX, -FLT_MAX);
QPointF pmin(FLT_MAX, FLT_MAX), pmax(-FLT_MAX, -FLT_MAX);
SMesh::Property_map<halfedge_descriptor, float> umap;
SMesh::Property_map<halfedge_descriptor, float> vmap;
@ -926,14 +926,14 @@ void Polyhedron_demo_parameterization_plugin::parameterize(const Parameterizatio
FT v = uv_pm[target(hd, sMesh)].y();
put(umap, *it, static_cast<float>(u));
put(vmap, *it, static_cast<float>(v));
if(u<min.x())
min.setX(u);
if(u>max.x())
max.setX(u);
if(v<min.y())
min.setY(v);
if(v>max.y())
max.setY(v);
if(u<pmin.x())
pmin.setX(u);
if(u>pmax.x())
pmax.setX(u);
if(v<pmin.y())
pmin.setY(v);
if(v>pmax.y())
pmax.setY(v);
}
Components* components = new Components(0);
@ -948,7 +948,7 @@ void Polyhedron_demo_parameterization_plugin::parameterize(const Parameterizatio
}
Scene_textured_facegraph_item* new_item = new Scene_textured_facegraph_item(tMesh);
UVItem *projection = new UVItem(components,new_item->textured_face_graph(), uv_borders, QRectF(min, max));
UVItem *projection = new UVItem(components,new_item->textured_face_graph(), uv_borders, QRectF(pmin, pmax));
projection->set_item_name(new_item_name);
new_item->setName(new_item_name);

8
Polyhedron/demo/Polyhedron/Scene_c3t3_item.cpp
View File

@ -393,10 +393,10 @@ struct Scene_c3t3_item_priv {
void invalidate_stats()
{
min_edges_length = std::numeric_limits<float>::max();
min_edges_length = (std::numeric_limits<float>::max)();
max_edges_length = 0;
mean_edges_length = 0;
min_dihedral_angle = std::numeric_limits<float>::max();
min_dihedral_angle = (std::numeric_limits<float>::max)();
max_dihedral_angle = 0;
mean_dihedral_angle = 0;
nb_subdomains = 0;
@ -404,8 +404,8 @@ struct Scene_c3t3_item_priv {
nb_cnc = 0;
nb_vertices = 0;
nb_tets = 0;
smallest_radius_radius = std::numeric_limits<float>::max();
smallest_edge_radius = std::numeric_limits<float>::max();
smallest_radius_radius = (std::numeric_limits<float>::max)();
smallest_edge_radius = (std::numeric_limits<float>::max)();
biggest_v_sma_cube = 0;
computed_stats = false;
}

2
Polyhedron/demo/Polyhedron/Scene_polylines_item.cpp
View File

@ -39,7 +39,7 @@ struct Scene_polylines_item_private {
{
nb_vertices = 0;
nb_edges = 0;
min_length = std::numeric_limits<double>::max();
min_length = (std::numeric_limits<double>::max)();
max_length = 0;
mean_length = 0;
computed_stats = false;

4
Polynomial/include/CGAL/Polynomial/bezout_matrix.h
View File

@ -109,8 +109,8 @@ hybrid_bezout_matrix(typename Polynomial_traits_d::Polynomial_d f,
B[i-sub-1][j-1] = s;
}
}
for (i = std::max(m+1, 1+sub); i <= n; i++) {
for (j = i-m; j <= std::min(i, n-sub); j++) {
for (i = (std::max)(m+1, 1+sub); i <= n; i++) {
for (j = i-m; j <= (std::min)(i, n-sub); j++) {
B[i-sub-1][j-1] = coeff(g,i-j);
}
}

4
Shape_detection/test/Shape_detection/include/test_efficient_RANSAC_generators.h
View File

@ -22,8 +22,8 @@
#include <fstream>
template <typename fl_t>
fl_t random_float(fl_t min, fl_t max) {
return fl_t(CGAL::get_default_random().get_double(min, max));
fl_t random_float(fl_t fmin, fl_t fmax) {
return fl_t(CGAL::get_default_random().get_double(fmin, fmax));
}
template <typename K>

8
Straight_skeleton_2/include/CGAL/Straight_skeleton_2/test.h
View File

@ -137,8 +137,8 @@ inline bool is_time_clearly_not_within_possibly_inexact_bisector_time_interval(
{
FT lSrcT = aBisector->opposite()->vertex()->time() ;
FT lTgtT = aBisector->vertex()->time() ;
FT lLoT = std::min(lSrcT,lTgtT);
FT lHiT = std::max(lSrcT,lTgtT);
FT lLoT = (std::min)(lSrcT,lTgtT);
FT lHiT = (std::max)(lSrcT,lTgtT);
return ( aT < lLoT || aT > lHiT )
&& is_possibly_inexact_time_clearly_not_equal_to(aT,lLoT)
@ -150,8 +150,8 @@ inline bool is_time_clearly_within_possibly_inexact_bisector_time_interval( FT c
{
FT lSrcT = aBisector->opposite()->vertex()->time() ;
FT lTgtT = aBisector->vertex()->time() ;
FT lLoT = std::min(lSrcT,lTgtT);
FT lHiT = std::max(lSrcT,lTgtT);
FT lLoT = (std::min)(lSrcT,lTgtT);
FT lHiT = (std::max)(lSrcT,lTgtT);
return ( lLoT < aT && aT < lHiT )
&& is_possibly_inexact_time_clearly_not_equal_to(aT,lLoT)

6
Stream_support/test/Stream_support/test_read_WKT.cpp
View File

@ -18,10 +18,10 @@ int main()
{
typedef CGAL::Point_2<Kernel> Point;
typedef std::vector<Point> Linestring;
typedef CGAL::Polygon_with_holes_2<Kernel> Polygon;
typedef CGAL::Polygon_with_holes_2<Kernel> Cgal_polygon;
typedef std::vector<Point> MultiPoint;
typedef std::vector<Linestring> MultiLinestring;
typedef std::vector<Polygon> MultiPolygon;
typedef std::vector<Cgal_polygon> MultiPolygon;
Point p;
{
@ -38,7 +38,7 @@ int main()
CGAL_assertion(ls.size() == 3);
}
{
Polygon poly;
Cgal_polygon poly;
std::ifstream in("data/polygon.wkt");
CGAL::read_polygon_WKT(in, poly);
in.close();

22
Stream_support/test/Stream_support/test_write_WKT.cpp
View File

@ -16,10 +16,10 @@
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
typedef CGAL::Point_2<Kernel> Point;
typedef std::vector<Point> Linestring;
typedef CGAL::Polygon_with_holes_2<Kernel> Polygon;
typedef CGAL::Polygon_with_holes_2<Kernel> Cgal_polygon;
typedef std::vector<Point> MultiPoint;
typedef std::vector<Linestring> MultiLinestring;
typedef std::vector<Polygon> MultiPolygon;
typedef std::vector<Cgal_polygon> MultiPolygon;
double fRand(double fMin, double fMax)
{
@ -42,7 +42,7 @@ Linestring generate_linestring()
ls.push_back(generate_point(0,15,0,15));
return ls;
}
Polygon generate_polygon()
Cgal_polygon generate_polygon()
{
Point bl,br, t;
bl = generate_point(-10,-5, -10, -5);
@ -56,22 +56,22 @@ Polygon generate_polygon()
xt(t.x()),
ymin(bl.y()),
ymid((ymax+ymin)/4.0);
Polygon::Polygon_2 border;
Cgal_polygon::Polygon_2 border;
border.push_back(bl);
border.push_back(t);
border.push_back(br);
Polygon::Polygon_2 hole1;
Cgal_polygon::Polygon_2 hole1;
hole1.push_back(Point((xt+xmax)/2, (ymin+ymid)/2));
hole1.push_back(Point(((xt+xmax)/2), ymid));
hole1.push_back(Point(xt+(xmax-xt)/4, (ymin+ymid)/2));
Polygon::Polygon_2 hole2;
Cgal_polygon::Polygon_2 hole2;
hole2.push_back(Point((xt+xmin)/2, (ymin+ymid)/2));
hole2.push_back(Point(((xt+xmin)/2), ymid));
hole2.push_back(Point(xmin+(xt-xmin)/4, (ymin+ymid)/2));
Polygon::Holes_container holes;
Cgal_polygon::Holes_container holes;
holes.push_back(hole1);
holes.push_back(hole2);
return Polygon(border, holes.begin(), holes.end());
return Cgal_polygon(border, holes.begin(), holes.end());
}
MultiPoint generate_multipoint()
{
@ -91,7 +91,7 @@ MultiLinestring generate_multilinestring()
}
MultiPolygon generate_multipolygon()
{
Polygon p1=generate_polygon(),
Cgal_polygon p1=generate_polygon(),
p2=generate_polygon();
MultiPolygon polies;
polies.push_back(p1);
@ -134,14 +134,14 @@ int main()
CGAL_assertion(ls == test_ls);
Polygon poly = generate_polygon();
Cgal_polygon poly = generate_polygon();
{
std::ofstream os("test.wkt");
os.precision(17);
CGAL::write_polygon_WKT(os, poly);
os.close();
}
Polygon test_poly;
Cgal_polygon test_poly;
{
std::ifstream is("test.wkt");
CGAL::read_polygon_WKT(is, test_poly);

4
Surface_mesh/include/CGAL/Surface_mesh/Properties.h
View File

@ -440,7 +440,7 @@ public:
{
for (std::size_t i=0; i<parrays_.size(); ++i)
parrays_[i]->reserve(n);
capacity_ = std::max(n, capacity_);
capacity_ = (std::max)(n, capacity_);
}
// resize all arrays to size n
@ -465,7 +465,7 @@ public:
for (std::size_t i=0; i<parrays_.size(); ++i)
parrays_[i]->push_back();
++size_;
capacity_ = (std::max(size_, capacity_));
capacity_ = ((std::max)(size_, capacity_));
}
// reset element to its default property values

10
Surface_mesh/include/CGAL/Surface_mesh/Surface_mesh.h
View File

@ -64,17 +64,17 @@ namespace CGAL {
typedef boost::uint32_t size_type;
/// Constructor. %Default construction creates an invalid index.
/// We write -1, which is <a href="https://en.cppreference.com/w/cpp/types/numeric_limits">
/// <tt>std::numeric_limits<size_type>::max()</tt></a>
/// <tt>(std::numeric_limits<size_type>::max)()</tt></a>
/// as `size_type` is an unsigned type.
explicit SM_Index(size_type _idx=(std::numeric_limits<size_type>::max)()) : idx_(_idx) {}
/// Get the underlying index of this index
operator size_type() const { return idx_; }
/// reset index to be invalid (index=std::numeric_limits<size_type>::max())
/// reset index to be invalid (index=(std::numeric_limits<size_type>::max)())
void reset() { idx_=(std::numeric_limits<size_type>::max)(); }
/// return whether the index is valid, i.e., the index is not equal to `%std::numeric_limits<size_type>::max()`.
/// return whether the index is valid, i.e., the index is not equal to `%(std::numeric_limits<size_type>::max)()`.
bool is_valid() const {
size_type inf = (std::numeric_limits<size_type>::max)();
return idx_ != inf;
@ -253,10 +253,10 @@ namespace CGAL {
// compatibility with OpenMesh handles
size_type idx() const { return (size_type)halfedge_ / 2; }
// resets index to be invalid (index=std::numeric_limits<size_type>::max())
// resets index to be invalid (index=(std::numeric_limits<size_type>::max)())
void reset() { halfedge_.reset(); }
// returns whether the index is valid, i.e., the index is not equal to std::numeric_limits<size_type>::max().
// returns whether the index is valid, i.e., the index is not equal to (std::numeric_limits<size_type>::max)().
bool is_valid() const { return halfedge_.is_valid(); }

2
Surface_mesh_approximation/include/CGAL/Variational_shape_approximation.h
View File

@ -54,7 +54,7 @@
#include <iostream>
#endif
#define CGAL_VSA_INVALID_TAG std::numeric_limits<std::size_t>::max()
#define CGAL_VSA_INVALID_TAG (std::numeric_limits<std::size_t>::max)()
namespace CGAL {

6
Surface_mesh_shortest_path/benchmark/Surface_mesh_shortest_path/benchmark_shortest_paths.cpp
View File

@ -99,8 +99,8 @@ public:
}
else
{
m_minimum = std::min(m_minimum, sample);
m_maximum = std::max(m_maximum, sample);
m_minimum = (std::min)(m_minimum, sample);
m_maximum = (std::max)(m_maximum, sample);
}
m_sum += sample;
++m_numSamples;
@ -227,7 +227,7 @@ void run_benchmarks(CGAL::Random& rand, size_t numTrials, size_t numSources, siz
outData.constructionTime.add_sample(elapsed.wall);
#if !defined(NDEBUG)
outData.peakMemoryUsage.add_sample(std::max(shortestPaths.peak_memory_usage(), shortestPaths.current_memory_usage()));
outData.peakMemoryUsage.add_sample((std::max)(shortestPaths.peak_memory_usage(), shortestPaths.current_memory_usage()));
#endif
for (size_t j = 0; j < numQueries; ++j)

2
Surface_mesh_shortest_path/include/CGAL/Surface_mesh_shortest_path/Surface_mesh_shortest_path.h
View File

@ -413,7 +413,7 @@ public:
+ (sizeof(Cone_expansion_event) + (sizeof(Cone_expansion_event*)) * m_peakQueueSize)
+ (sizeof(Cone_tree_node) * m_nodesAtPeakQueue);
return std::max(peakNodeUsage, peakQueueUsage);
return (std::max)(peakNodeUsage, peakQueueUsage);
}
/// \endcond

12
Surface_mesher/archive/include/CGAL/enriched_polyhedron.h
View File

@ -323,13 +323,13 @@ public :
{
const Point& p = pVertex->point();
xmin = std::min(xmin,p.x());
ymin = std::min(ymin,p.y());
zmin = std::min(zmin,p.z());
xmin = (std::min)(xmin,p.x());
ymin = (std::min)(ymin,p.y());
zmin = (std::min)(zmin,p.z());
xmax = std::max(xmax,p.x());
ymax = std::max(ymax,p.y());
zmax = std::max(zmax,p.z());
xmax = (std::max)(xmax,p.x());
ymax = (std::max)(ymax,p.y());
zmax = (std::max)(zmax,p.z());
}
m_bbox = Iso_cuboid(xmin,ymin,zmin,
xmax,ymax,zmax);

4
Surface_mesher/include/CGAL/vtkSurfaceMesherContourFilter.h
View File

@ -130,8 +130,8 @@ int vtkCGALSurfaceMesherContourFilter::RequestData(
return 0;
Gray_level_image gray_level_image(image, Value);
GT::FT radius = std::max(image.xdim() * image.vx(),
std::max(image.ydim() * image.vy(),
GT::FT radius = (std::max)(image.xdim() * image.vx(),
(std::max)(image.ydim() * image.vy(),
image.zdim() * image.vz())
);
GT::Sphere_3 bounding_sphere(GT::Point_3(image.xdim() * image.vx()/2.,

8
Triangulation/include/CGAL/internal/Combination_enumerator.h
View File

@ -37,11 +37,11 @@ public:
// For generating all the combinations of |k| distinct elements in the
// interval [min, max] (both included)
Combination_enumerator(const int k, const int min, const int max)
: combi_(k), k_(k), min_(min), max_(max), max_at_pos_0_(max + 1 - k)
Combination_enumerator(const int k, const int imin, const int imax)
: combi_(k), k_(k), min_(imin), max_(imax), max_at_pos_0_(imax + 1 - k)
{
CGAL_assertion_msg( min <= max, "min is larger than max");
CGAL_assertion_msg( 1 <= k && k <= ( max - min + 1 ), "wrong value of k");
CGAL_assertion_msg( imin <= imax, "min is larger than max");
CGAL_assertion_msg( 1 <= k && k <= ( imax - imin + 1 ), "wrong value of k");
init();
}