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

Fixes for min/max

This commit is contained in:
Maxime Gimeno 2020-04-21 10:03:00 +02:00
parent 0b48d2867d
commit 50766d9d03
62 changed files with 669 additions and 188 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

@ -857,8 +857,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)
{
@ -877,7 +877,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();
@ -894,8 +894,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

@ -118,10 +118,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

@ -3031,8 +3031,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
@ -3112,9 +3112,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

@ -581,7 +581,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");
@ -921,7 +921,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
@ -941,7 +941,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());

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

@ -26,6 +26,12 @@
#include <CGAL/boost/graph/iterator.h>
#include <boost/unordered_set.hpp>
#include <CGAL/boost/graph/Dual.h>
#include <boost/graph/filtered_graph.hpp>
#include <boost/iterator/filter_iterator.hpp>
#include <CGAL/boost/graph/alpha_expansion_graphcut.h>
#include <CGAL/squared_distance_3.h>
namespace CGAL {
@ -66,6 +72,225 @@ extract_selection_boundary(
}
return out;
}
template <typename GeomTraits,
typename FaceGraph,
typename IsSelectedMap,
typename FaceIndexMap,
typename VertexPointMap>
struct Regularization_graph
{
typedef boost::graph_traits<FaceGraph> GT;
typedef typename GT::face_descriptor fg_face_descriptor;
typedef typename GT::face_iterator fg_face_iterator;
typedef typename GT::halfedge_descriptor fg_halfedge_descriptor;
typedef typename GT::edge_descriptor fg_edge_descriptor;
typedef typename GT::edge_iterator fg_edge_iterator;
typedef typename GT::vertex_descriptor fg_vertex_descriptor;
typedef fg_face_descriptor vertex_descriptor;
typedef fg_face_iterator vertex_iterator;
typedef fg_edge_descriptor edge_descriptor;
typedef boost::undirected_tag directed_category;
typedef boost::disallow_parallel_edge_tag edge_parallel_category;
typedef boost::edge_list_graph_tag traversal_category;
struct Filter_border_edges
{
FaceGraph* fg;
Filter_border_edges (FaceGraph& fg) : fg (&fg) { }
bool operator() (const fg_edge_descriptor ed) const
{
return !is_border (ed, *fg);
}
};
typedef boost::filter_iterator<Filter_border_edges, fg_edge_iterator> edge_iterator;
struct Vertex_label_map
{
typedef vertex_descriptor key_type;
typedef std::size_t value_type;
typedef std::size_t& reference;
typedef boost::lvalue_property_map_tag category;
Regularization_graph* rg;
Vertex_label_map (Regularization_graph* rg)
: rg (rg) { }
friend reference get (const Vertex_label_map& map, key_type k)
{
return (map.rg->labels)[get(map.rg->face_index_map,k)];
}
friend void put (const Vertex_label_map& map, key_type k, const value_type& v)
{
(map.rg->labels)[get(map.rg->face_index_map,k)] = v;
}
};
struct Vertex_label_probability_map
{
typedef vertex_descriptor key_type;
typedef std::vector<double> value_type;
typedef value_type reference;
typedef boost::readable_property_map_tag category;
const Regularization_graph* rg;
Vertex_label_probability_map (const Regularization_graph* rg)
: rg (rg)
{ }
friend reference get (const Vertex_label_probability_map& pmap, key_type fd)
{
double value = (1. - pmap.rg->weight) * pmap.rg->area (fd) / pmap.rg->total_area;
std::vector<double> out(2);
if (get(pmap.rg->is_selected_map, fd))
{
if (pmap.rg->prevent_unselection)
out[0] = (std::numeric_limits<double>::max)();
else
out[0] = value;
out[1] = 0.;
}
else
{
out[0] = 0.;
out[1] = value;
}
return out;
}
};
struct Edge_cost_map
{
typedef edge_descriptor key_type;
typedef double value_type;
typedef value_type reference;
typedef boost::readable_property_map_tag category;
const Regularization_graph* rg;
Edge_cost_map (const Regularization_graph* rg)
: rg (rg) { }
friend reference get (const Edge_cost_map& pmap, key_type ed)
{
fg_vertex_descriptor esource = source(ed, pmap.rg->fg);
fg_vertex_descriptor etarget = target(ed, pmap.rg->fg);
// Cost
double edge_length = std::sqrt(CGAL::squared_distance (get (pmap.rg->vertex_point_map, esource),
get (pmap.rg->vertex_point_map, etarget)));
return pmap.rg->weight * edge_length / pmap.rg->total_length;
}
};
FaceGraph& fg;
IsSelectedMap is_selected_map;
FaceIndexMap face_index_map;
VertexPointMap vertex_point_map;
double total_length;
double total_area;
double weight;
bool prevent_unselection;
std::vector<std::size_t> labels;
Regularization_graph (FaceGraph& fg,
IsSelectedMap is_selected_map,
FaceIndexMap face_index_map,
VertexPointMap vertex_point_map,
double weight,
bool prevent_unselection)
: fg (fg),
is_selected_map (is_selected_map),
face_index_map (face_index_map),
vertex_point_map (vertex_point_map),
total_length(0),
total_area(0),
weight (weight),
prevent_unselection (prevent_unselection)
{
labels.reserve(num_faces(fg));
std::size_t nb_selected = 0;
for (fg_face_descriptor fd : faces(fg))
{
if (get(is_selected_map,fd))
{
labels.push_back(1);
++ nb_selected;
}
else
labels.push_back(0);
}
// Compute normalization factors
for (fg_edge_descriptor ed : edges(fg))
total_length += length (ed);
for (fg_face_descriptor fd : faces(fg))
total_area += area (fd);
}
double length (fg_edge_descriptor ed) const
{
fg_vertex_descriptor esource = source(ed, fg);
fg_vertex_descriptor etarget = target(ed, fg);
return approximate_sqrt (typename GeomTraits::Compute_squared_distance_3()
(get (vertex_point_map, esource),
get (vertex_point_map, etarget)));
}
double area (fg_face_descriptor fd) const
{
fg_halfedge_descriptor hd = halfedge (fd, fg);
fg_halfedge_descriptor nhd = next (hd, fg);
return approximate_sqrt (typename GeomTraits::Compute_squared_area_3()
(get (vertex_point_map, source (hd, fg)),
get (vertex_point_map, target (hd, fg)),
get (vertex_point_map, target (nhd, fg))));
}
friend CGAL::Iterator_range<vertex_iterator>
vertices (const Regularization_graph& graph)
{
return faces (graph.fg);
}
friend std::size_t num_vertices (const Regularization_graph& graph) { return num_faces(graph.fg); }
friend CGAL::Iterator_range<edge_iterator>
edges (const Regularization_graph& graph)
{
return CGAL::make_range (boost::make_filter_iterator
(Filter_border_edges(graph.fg),
begin(edges(graph.fg)), end(edges(graph.fg))),
boost::make_filter_iterator
(Filter_border_edges(graph.fg),
end(edges(graph.fg)), end(edges(graph.fg))));
}
friend vertex_descriptor source (edge_descriptor ed, const Regularization_graph& graph)
{
return face (halfedge (ed, graph.fg), graph.fg);
}
friend vertex_descriptor target (edge_descriptor ed, const Regularization_graph& graph)
{
return face (opposite(halfedge (ed, graph.fg), graph.fg), graph.fg);
}
Vertex_label_map vertex_label_map() { return Vertex_label_map(this); }
Vertex_label_probability_map vertex_label_probability_map() const
{ return Vertex_label_probability_map(this); }
Edge_cost_map edge_cost_map() const
{ return Edge_cost_map(this); }
};
} //end of namespace internal
@ -213,6 +438,265 @@ reduce_face_selection(
return out;
}
/*!
\ingroup PkgBGLSelectionFct
regularizes a selection in order to minimize the length of the
border of the selection.
The alpha expansion algorithm is used (see
`CGAL::alpha_expansion_graphcut()`) using the length of the edge
between two faces as the edge cost and the initial
selected/unselected property of a face as the face cost.
If `prevent_unselection` is set to `true`, the cost of unselecting a
face is set to infinity, which forces the regularization to only
select new faces and ensures that the regularization keeps all
selected faces.
\tparam TriangleMesh a model of `FaceGraph`
\tparam IsSelectedMap a model of `ReadWritePropertyMap` with
`boost::graph_traits<TriangleMesh>::%face_descriptor` as key type and
`bool` as value type
\tparam NamedParameters a sequence of named parameters
\param mesh the mesh containing the selected faces.
\param is_selected indicates if a face is part of the selection. It
is updated by the function to accommodate faces added or removed
from the selection.
\param weight sets the tradeoff between data fidelity and
regularity, ranging from 0 (no regularization at all, selection is
left unaltered) to 1 (maximum regularization, usually selects or
unselects everything so that the length of the border of the
selection is 0)
\param np optional sequence of named parameters among the ones listed below
\cgalNamedParamsBegin
\cgalParamBegin{face_index_map}
the property map with the indices associated to the faces of `mesh`
\cgalParamEnd
\cgalParamBegin{vertex_point_map}
the property map with the points associated to the vertices of `mesh`
\cgalParamEnd
\cgalParamBegin{prevent_unselection}
if `true` only new faces can be selected, if `false` (default) some
faces can be unselected
\cgalParamEnd
\cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
\cgalNamedParamsEnd
*/
template <typename TriangleMesh, typename IsSelectedMap, typename NamedParameters>
void
regularize_face_selection_borders(
TriangleMesh& mesh,
IsSelectedMap is_selected,
double weight,
const NamedParameters& np)
{
using parameters::choose_parameter;
using parameters::get_parameter;
CGAL_precondition (0.0 <= weight && weight < 1.0);
typedef boost::graph_traits<TriangleMesh> GT;
typedef typename GT::face_descriptor mesh_face_descriptor;
typedef typename GetInitializedFaceIndexMap<TriangleMesh, NamedParameters>::type FaceIndexMap;
FaceIndexMap face_index_map = CGAL::get_initialized_face_index_map(mesh, np);
typedef typename GetVertexPointMap<TriangleMesh, NamedParameters>::const_type VertexPointMap;
VertexPointMap vertex_point_map
= choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, mesh));
typedef typename GetGeomTraits<TriangleMesh, NamedParameters>::type Kernel;
bool prevent_unselection = choose_parameter(get_parameter(np, internal_np::prevent_unselection),
false);
internal::Regularization_graph<Kernel, TriangleMesh, IsSelectedMap, FaceIndexMap,
VertexPointMap>
graph (mesh, is_selected,
face_index_map,
vertex_point_map,
weight,
prevent_unselection);
alpha_expansion_graphcut (graph,
graph.edge_cost_map(),
graph.vertex_label_probability_map(),
graph.vertex_label_map(),
CGAL::parameters::vertex_index_map
(face_index_map));
for (mesh_face_descriptor fd : faces(mesh))
put(is_selected, fd, graph.labels[get(face_index_map,fd)]);
}
/// \cond SKIP_IN_MANUAL
// variant with default np
template <typename TriangleMesh, typename IsSelectedMap>
void
regularize_face_selection_borders(
TriangleMesh& fg,
IsSelectedMap is_selected,
double weight)
{
regularize_face_selection_borders (fg, is_selected, weight,
CGAL::parameters::all_default());
}
/// \endcond
/// \cond SKIP_IN_MANUAL
// TODO: improve and document if useful
//
// Variant of regularization without graphcut but with brut-force
// local expansions. Can be interesting in some cases but too
// experimental/messy so far to be officially integrated.
template <class FaceGraph, class IsSelectedMap, class VertexPointMap>
void
regularize_face_selection_borders(
FaceGraph& fg,
IsSelectedMap is_selected,
VertexPointMap vertex_point_map)
{
typedef boost::graph_traits<FaceGraph> GT;
typedef typename GT::face_descriptor fg_face_descriptor;
typedef typename GT::halfedge_descriptor fg_halfedge_descriptor;
typedef typename GT::edge_descriptor fg_edge_descriptor;
typedef typename GT::vertex_descriptor fg_vertex_descriptor;
// TODO: this is a quick and dirty version, the complexity is
// crazy and it should be easy to do better (with priority queues,
// for example)
auto border_length =
[&]() -> double
{
double out = 0.;
for(fg_edge_descriptor ed : edges(fg))
{
fg_face_descriptor f0 = face (halfedge (ed, fg), fg);
fg_face_descriptor f1 = face (opposite(halfedge (ed, fg), fg), fg);
if (get(is_selected,f0) == get(is_selected,f1))
continue;
fg_vertex_descriptor esource = source(ed, fg);
fg_vertex_descriptor etarget = target(ed, fg);
out += std::sqrt(CGAL::squared_distance (get (vertex_point_map, esource),
get (vertex_point_map, etarget)));
}
return out;
};
// First: try edges
while (true)
{
fg_edge_descriptor chosen;
double length_before = border_length();
double shortest_length = length_before;
for (fg_edge_descriptor ed : edges(fg))
{
fg_face_descriptor selected = face (halfedge (ed, fg), fg);
fg_face_descriptor unselected = face (opposite(halfedge (ed, fg), fg), fg);
if (get(is_selected,selected) == get(is_selected,unselected))
continue;
if (get(is_selected, unselected))
std::swap (selected, unselected);
put(is_selected, unselected, true);
double length_after = border_length();
if (length_after < shortest_length)
{
chosen = ed;
shortest_length = length_after;
}
// Cancel
put(is_selected, unselected, false);
}
if (shortest_length == length_before)
break;
fg_face_descriptor selected = face (halfedge (chosen, fg), fg);
fg_face_descriptor unselected = face (opposite(halfedge (chosen, fg), fg), fg);
if (get(is_selected,selected) == get(is_selected,unselected))
continue;
if (get(is_selected, unselected))
std::swap (selected, unselected);
put(is_selected, unselected, true);
}
// Second: try 1-ring of vertices
while (true)
{
fg_vertex_descriptor chosen;
double length_before = border_length();
double shortest_length = length_before;
for (fg_vertex_descriptor vd : vertices(fg))
{
fg_halfedge_descriptor hd = halfedge(vd, fg);
bool adjacent_to_selected = false, adjacent_to_nonselected = false;
for (fg_face_descriptor fd : faces_around_target (hd, fg))
{
if (get(is_selected, fd))
adjacent_to_selected = true;
else
adjacent_to_nonselected = true;
if (adjacent_to_selected && adjacent_to_nonselected)
break;
}
if (!(adjacent_to_selected && adjacent_to_nonselected))
continue;
std::vector<fg_face_descriptor> newly_selected;
for (fg_face_descriptor fd : faces_around_target (hd, fg))
{
if (!get(is_selected, fd))
{
newly_selected.push_back (fd);
put(is_selected, fd, true);
}
}
double length_after = border_length();
if (length_after < shortest_length)
{
chosen = vd;
shortest_length = length_after;
}
// Cancel
for (fg_face_descriptor fd : newly_selected)
put(is_selected, fd, false);
}
if (shortest_length == length_before)
break;
fg_halfedge_descriptor hd = halfedge (chosen, fg);
for (fg_face_descriptor fd : faces_around_target (hd, fg))
put(is_selected, fd, true);
}
}
/// \endcond
/*!
\ingroup PkgBGLSelectionFct
@ -662,4 +1146,3 @@ bool is_selection_a_topological_disk(const FaceRange& face_selection,
} //end of namespace CGAL
#endif //CGAL_BOOST_GRAPH_SELECTION_H

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;

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

@ -103,7 +103,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));

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

@ -114,7 +114,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
Classification/include/CGAL/Classification/Feature/Cluster_vertical_extent.h
View File

@ -67,8 +67,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

@ -97,7 +97,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)
@ -109,8 +109,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

@ -90,13 +90,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

@ -90,13 +90,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

@ -90,15 +90,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

@ -49,15 +49,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

@ -135,7 +135,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

@ -39,20 +39,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;
BOOST_FOREACH(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);
BOOST_FOREACH(vertex_descriptor vd , vertices(tm)){

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

@ -43,19 +43,19 @@ int main()
//Point_3 sp = sm.point(source);
vertex_descriptor far;
vertex_descriptor vfar;
// double sdistance = 0;
BOOST_FOREACH(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);
BOOST_FOREACH(vertex_descriptor vd , vertices(sm)){

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

@ -37,19 +37,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;
BOOST_FOREACH(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);
@ -63,7 +63,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();
@ -71,7 +71,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

@ -37,19 +37,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;
BOOST_FOREACH(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);
@ -63,7 +63,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();
@ -71,7 +71,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

@ -319,7 +319,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

@ -32,7 +32,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

@ -34,7 +34,7 @@ namespace CGAL {
#ifdef CGAL_EIGEN3_ENABLED
const int UNKNOWN_DIMENSION=Eigen::Dynamic;
#elif defined CGAL_CXX11
const int UNKNOWN_DIMENSION=std::numeric_limits<int>::max();
const int UNKNOWN_DIMENSION=(std::numeric_limits<int>::max)();
#else
const int UNKNOWN_DIMENSION=(unsigned)-1/2;
#endif

4
Linear_cell_complex/benchmark/Linear_cell_complex_2/surface_mesh/IO_off.cpp
View File

@ -71,7 +71,7 @@ bool read_off_ascii(Surface_mesh& mesh,
// #Vertice, #Faces, #Edges
items = fscanf(in, "%d %d %d\n", (int*)&nV, (int*)&nF, (int*)&nE);
mesh.clear();
mesh.reserve(nV, std::max(3*nV, nE), nF);
mesh.reserve(nV, (std::max)(3*nV, nE), nF);
// read vertices: pos [normal] [color] [texcoord]
@ -186,7 +186,7 @@ bool read_off_binary(Surface_mesh& mesh,
read(in, nF);
read(in, nE);
mesh.clear();
mesh.reserve(nV, std::max(3*nV, nE), nF);
mesh.reserve(nV, (std::max)(3*nV, nE), nF);
// read vertices: pos [normal] [color] [texcoord]

4
Linear_cell_complex/benchmark/Linear_cell_complex_2/surface_mesh/Vector.h
View File

@ -223,7 +223,7 @@ public:
Vector<Scalar,N>& normalize()
{
Scalar n = norm(*this);
if (n > std::numeric_limits<Scalar>::min())
if (n > (std::numeric_limits<Scalar>::min)())
*this *= 1.0/n;
return *this;
}
@ -513,7 +513,7 @@ public:
Vector<Scalar,3>& normalize()
{
Scalar n = norm(*this);
n = (n > std::numeric_limits<Scalar>::min()) ? 1.0/n : 0.0;
n = (n > (std::numeric_limits<Scalar>::min)()) ? 1.0/n : 0.0;
x *= n;
y *= n;
z *= n;

2
Linear_cell_complex/benchmark/Linear_cell_complex_3/cgogn_performance_3.h
View File

@ -63,7 +63,7 @@ private:
Dart getShortestEdge()
{
double weight = std::numeric_limits<double>::max();
double weight = (std::numeric_limits<double>::max)();
Dart dart = NIL;
bool boundary=false;

2
Linear_cell_complex/benchmark/Linear_cell_complex_3/lcc_performance_3.h
View File

@ -319,7 +319,7 @@ private:
Dart_handle getShortestEdge()
{
double weight = std::numeric_limits<double>::max();
double weight = (std::numeric_limits<double>::max)();
Dart_handle dart = lcc.null_dart_handle;
int m=lcc.get_new_mark();

2
Linear_cell_complex/benchmark/Linear_cell_complex_3/openvolumemesh_performance.h
View File

@ -129,7 +129,7 @@ private:
// Find the mesh's shortest edge
EdgeHandle getShortestEdge()
{
double max_weight = std::numeric_limits<double>::max();
double max_weight = (std::numeric_limits<double>::max)();
EdgeHandle eh = Mesh::InvalidEdgeHandle;
bool boundary=false;

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

@ -41,15 +41,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());
@ -128,19 +128,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

@ -452,7 +452,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

@ -384,24 +384,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

@ -172,7 +172,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:

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

@ -52,9 +52,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),
@ -73,9 +73,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

@ -70,17 +70,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

@ -617,15 +617,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();
}
}

4
Point_set_shape_detection_3/test/Point_set_shape_detection_3/generators.h
View File

@ -10,8 +10,8 @@
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>

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

@ -61,9 +61,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]) );
@ -93,9 +93,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]) );

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

@ -965,7 +965,6 @@ void MainWindow::updateViewerBBox(bool recenter = true)
for(int i=0; i<3; ++i)
{
offset[i] = -bbox_center[i];
}
if(offset != viewer->offset())
{

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

@ -125,8 +125,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
{
BOOST_FOREACH(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()

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;
}

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

@ -540,16 +540,15 @@ 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];
}
_bbox = Scene_item::Bbox(min.x(),min.y(),min.z(),max.x(),max.y(),max.z());
_bbox = Scene_item::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

@ -485,10 +485,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

@ -306,7 +306,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

@ -150,7 +150,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)
{

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

@ -438,10 +438,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;
@ -449,8 +449,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

@ -30,7 +30,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

@ -118,8 +118,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);
}
}

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

@ -146,8 +146,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)
@ -159,8 +159,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)

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

@ -449,7 +449,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
@ -474,7 +474,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

@ -74,17 +74,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;
@ -222,10 +222,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(); }
// Are two indices equal?

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

@ -64,7 +64,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 {

8
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)
@ -333,4 +333,4 @@ int main(int argc, char* argv[])
}
return EXIT_SUCCESS;
}
}

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

@ -422,7 +422,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

@ -332,13 +332,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

@ -139,8 +139,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

@ -46,11 +46,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();
}