|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r56352 - in sandbox/gtl/boost/polygon: . detail
From: lucanus.j.simonson_at_[hidden]
Date: 2009-09-21 19:23:32
Author: ljsimons
Date: 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
New Revision: 56352
URL: http://svn.boost.org/trac/boost/changeset/56352
Log:
fixed all MSVC warnings
Text files modified:
sandbox/gtl/boost/polygon/detail/boolean_op.hpp | 18 ++
sandbox/gtl/boost/polygon/detail/boolean_op_45.hpp | 44 +++++-
sandbox/gtl/boost/polygon/detail/max_cover.hpp | 16 +-
sandbox/gtl/boost/polygon/detail/polygon_45_formation.hpp | 28 +++-
sandbox/gtl/boost/polygon/detail/polygon_45_set_view.hpp | 20 +++
sandbox/gtl/boost/polygon/detail/polygon_45_touch.hpp | 2
sandbox/gtl/boost/polygon/detail/polygon_90_set_view.hpp | 3
sandbox/gtl/boost/polygon/detail/polygon_arbitrary_formation.hpp | 10
sandbox/gtl/boost/polygon/detail/polygon_formation.hpp | 2
sandbox/gtl/boost/polygon/detail/polygon_set_view.hpp | 46 ++++---
sandbox/gtl/boost/polygon/detail/rectangle_formation.hpp | 2
sandbox/gtl/boost/polygon/detail/scan_arbitrary.hpp | 35 ++++-
sandbox/gtl/boost/polygon/detail/transform_detail.hpp | 108 +++++++++---------
sandbox/gtl/boost/polygon/gtl_boost_unit_test.cpp | 228 +++++++++++++++++++++------------------
sandbox/gtl/boost/polygon/interval_concept.hpp | 7
sandbox/gtl/boost/polygon/interval_data.hpp | 18 ++
sandbox/gtl/boost/polygon/isotropy.hpp | 4
sandbox/gtl/boost/polygon/point_3d_data.hpp | 6
sandbox/gtl/boost/polygon/point_data.hpp | 18 ++
sandbox/gtl/boost/polygon/polygon_45_set_concept.hpp | 2
sandbox/gtl/boost/polygon/polygon_45_set_data.hpp | 75 ++++++++----
sandbox/gtl/boost/polygon/polygon_45_set_traits.hpp | 4
sandbox/gtl/boost/polygon/polygon_90_set_data.hpp | 4
sandbox/gtl/boost/polygon/polygon_90_set_traits.hpp | 8
sandbox/gtl/boost/polygon/polygon_set_data.hpp | 16 +-
sandbox/gtl/boost/polygon/polygon_set_traits.hpp | 4
sandbox/gtl/boost/polygon/polygon_traits.hpp | 38 +++---
sandbox/gtl/boost/polygon/transform.hpp | 36 ++++--
28 files changed, 489 insertions(+), 313 deletions(-)
Modified: sandbox/gtl/boost/polygon/detail/boolean_op.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/detail/boolean_op.hpp (original)
+++ sandbox/gtl/boost/polygon/detail/boolean_op.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -85,12 +85,24 @@
template <class T>
class BinaryCount {
public:
- inline BinaryCount() : counts_() { counts_[0] = counts_[1] = 0; }
+ inline BinaryCount()
+#ifndef BOOST_POLYGON_MSVC
+ : counts_()
+#endif
+ { counts_[0] = counts_[1] = 0; }
// constructs from two integers
- inline BinaryCount(int countL, int countR) : counts_() { counts_[0] = countL, counts_[1] = countR; }
+ inline BinaryCount(int countL, int countR)
+#ifndef BOOST_POLYGON_MSVC
+ : counts_()
+#endif
+ { counts_[0] = countL, counts_[1] = countR; }
inline BinaryCount& operator=(int count) { counts_[0] = count, counts_[1] = count; return *this; }
inline BinaryCount& operator=(const BinaryCount& that);
- inline BinaryCount(const BinaryCount& that) : counts_() { *this = that; }
+ inline BinaryCount(const BinaryCount& that)
+#ifndef BOOST_POLYGON_MSVC
+ : counts_()
+#endif
+ { *this = that; }
inline bool operator==(const BinaryCount& that) const;
inline bool operator!=(const BinaryCount& that) const { return !((*this) == that);}
inline BinaryCount& operator+=(const BinaryCount& that);
Modified: sandbox/gtl/boost/polygon/detail/boolean_op_45.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/detail/boolean_op_45.hpp (original)
+++ sandbox/gtl/boost/polygon/detail/boolean_op_45.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -16,10 +16,22 @@
class Count2 {
public:
- inline Count2() : counts() { counts[0] = counts[1] = 0; }
+ inline Count2()
+#ifndef BOOST_POLYGON_MSVC
+ : counts()
+#endif
+ { counts[0] = counts[1] = 0; }
//inline Count2(int count) { counts[0] = counts[1] = count; }
- inline Count2(int count1, int count2) : counts() { counts[0] = count1; counts[1] = count2; }
- inline Count2(const Count2& count) : counts() { counts[0] = count.counts[0]; counts[1] = count.counts[1]; }
+ inline Count2(int count1, int count2)
+#ifndef BOOST_POLYGON_MSVC
+ : counts()
+#endif
+ { counts[0] = count1; counts[1] = count2; }
+ inline Count2(const Count2& count)
+#ifndef BOOST_POLYGON_MSVC
+ : counts()
+#endif
+ { counts[0] = count.counts[0]; counts[1] = count.counts[1]; }
inline bool operator==(const Count2& count) const { return counts[0] == count.counts[0] && counts[1] == count.counts[1]; }
inline bool operator!=(const Count2& count) const { return !((*this) == count); }
inline Count2& operator=(int count) { counts[0] = counts[1] = count; return *this; }
@@ -357,6 +369,9 @@
}
template <int op>
static bool applyLogic(Count2 count) {
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (disable: 4127)
+#endif
if(op == 0) { //apply or
return count[0] > 0 || count[1] > 0;
} else if(op == 1) { //apply and
@@ -367,6 +382,9 @@
return (count[0] > 0) ^ (count[1] > 0);
} else
return false;
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (default: 4127)
+#endif
}
template <int op>
@@ -386,14 +404,20 @@
template <int op>
static bool applyLogic(Count1 count) {
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (disable: 4127)
+#endif
if(op == 0) { //apply or
return count.count_ > 0;
} else if(op == 1) { //apply and
return count.count_ > 1;
} else if(op == 3) { //apply xor
- return count.count_ % 2;
+ return (count.count_ % 2) != 0;
} else
return false;
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (default: 4127)
+#endif
}
template <int op>
@@ -766,9 +790,9 @@
//std::cout << "0, ";
Unit y1 = iter1->evalAtX(x_);
Unit y2 = iter2->evalAtX(x_);
- LongUnit delta = (LongUnit)abs((LongUnit)y1 - (LongUnit)y2);
- if(delta + x_ <= (std::numeric_limits<Unit>::max)())
- crossQueue_.insert(crossQueue_.end(), Point(x_ + delta, y1));
+ LongUnit delta = local_abs(LongUnit(y1) - LongUnit(y2));
+ if(delta + static_cast<LongUnit>(x_) <= (std::numeric_limits<Unit>::max)())
+ crossQueue_.insert(crossQueue_.end(), Point(x_ + static_cast<Unit>(delta), y1));
//std::cout << Point(x_ + delta, y1);
}
@@ -794,14 +818,14 @@
LongUnit halfDelta2 = (LongUnit)((((LongUnit)y1) - y2)/2);
//note that halfDelta2 has been truncated
if(halfDelta2 + x_ <= UnitMax && halfDelta2 + y2 <= UnitMax) {
- crossQueue_.insert(crossQueue_.end(), Point(x_+halfDelta2, y2+halfDelta2));
- crossQueue_.insert(crossQueue_.end(), Point(x_+halfDelta2, y2+halfDelta2+1));
+ crossQueue_.insert(crossQueue_.end(), Point(x_+static_cast<Unit>(halfDelta2), y2+static_cast<Unit>(halfDelta2)));
+ crossQueue_.insert(crossQueue_.end(), Point(x_+static_cast<Unit>(halfDelta2), y2+static_cast<Unit>(halfDelta2)+1));
}
}
} else {
LongUnit halfDelta = (LongUnit)((((LongUnit)y1) - y2)/2);
if(halfDelta + x_ <= UnitMax && halfDelta + y2 <= UnitMax)
- crossQueue_.insert(crossQueue_.end(), Point(x_+halfDelta, y2+halfDelta));
+ crossQueue_.insert(crossQueue_.end(), Point(x_+static_cast<Unit>(halfDelta), y2+static_cast<Unit>(halfDelta)));
//std::cout << Point(x_+halfDelta, y2+halfDelta);
}
}
Modified: sandbox/gtl/boost/polygon/detail/max_cover.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/detail/max_cover.hpp (original)
+++ sandbox/gtl/boost/polygon/detail/max_cover.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -96,10 +96,10 @@
bool iresult = intersect(rectIvl, nodeIvl, false);
bool tresult = !node->tracedPath(rectIvl);
//std::cout << (itr != node->end()) << " " << iresult << " " << tresult << std::endl;
- Rectangle nextRect = Rectangle(rectIvl, rectIvl);
+ Rectangle nextRect1 = Rectangle(rectIvl, rectIvl);
Unit low = rect.get(orient.get_perpendicular()).low();
Unit high = node->rect.get(orient.get_perpendicular()).high();
- nextRect.set(orient.get_perpendicular(), Interval(low, high));
+ nextRect1.set(orient.get_perpendicular(), Interval(low, high));
if(iresult && tresult) {
node->addPath(rectIvl);
bool writeOut = true;
@@ -110,13 +110,13 @@
if(contains(nodeIvl3, rectIvl, true)) writeOut = false;
//std::cout << "child " << (*itr2)->rect << std::endl;
}
- Rectangle nextRect = Rectangle(rectIvl, rectIvl);
- Unit low = rect.get(orient.get_perpendicular()).low();
- Unit high = node->rect.get(orient.get_perpendicular()).high();
- nextRect.set(orient.get_perpendicular(), Interval(low, high));
+ Rectangle nextRect2 = Rectangle(rectIvl, rectIvl);
+ Unit low2 = rect.get(orient.get_perpendicular()).low();
+ Unit high2 = node->rect.get(orient.get_perpendicular()).high();
+ nextRect2.set(orient.get_perpendicular(), Interval(low2, high2));
if(writeOut) {
//std::cout << "write out " << nextRect << std::endl;
- outputContainer.push_back(copy_construct<typename cT::value_type, Rectangle>(nextRect));
+ outputContainer.push_back(copy_construct<typename cT::value_type, Rectangle>(nextRect2));
} else {
//std::cout << "supress " << nextRect << std::endl;
}
@@ -124,7 +124,7 @@
if(itr != node->end() && iresult && tresult) {
//std::cout << "recurse into child\n";
stack.push_back(stack_element(node, rect, itr));
- rect = nextRect;
+ rect = nextRect1;
node = *itr;
itr = node->begin();
} else {
Modified: sandbox/gtl/boost/polygon/detail/polygon_45_formation.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/detail/polygon_45_formation.hpp (original)
+++ sandbox/gtl/boost/polygon/detail/polygon_45_formation.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -394,20 +394,36 @@
class Vertex45CountT {
public:
typedef ct count_type;
- inline Vertex45CountT() : counts() { counts[0] = counts[1] = counts[2] = counts[3] = 0; }
+ inline Vertex45CountT()
+#ifndef BOOST_POLYGON_MSVC
+ : counts()
+#endif
+ { counts[0] = counts[1] = counts[2] = counts[3] = 0; }
//inline Vertex45CountT(ct count) { counts[0] = counts[1] = counts[2] = counts[3] = count; }
inline Vertex45CountT(const ct& count1, const ct& count2, const ct& count3,
- const ct& count4) : counts() {
+ const ct& count4)
+#ifndef BOOST_POLYGON_MSVC
+ : counts()
+#endif
+ {
counts[0] = count1;
counts[1] = count2;
counts[2] = count3;
counts[3] = count4;
}
- inline Vertex45CountT(const Vertex45& vertex) : counts() {
+ inline Vertex45CountT(const Vertex45& vertex)
+#ifndef BOOST_POLYGON_MSVC
+ : counts()
+#endif
+ {
counts[0] = counts[1] = counts[2] = counts[3] = 0;
(*this) += vertex;
}
- inline Vertex45CountT(const Vertex45CountT& count) : counts() {
+ inline Vertex45CountT(const Vertex45CountT& count)
+#ifndef BOOST_POLYGON_MSVC
+ : counts()
+#endif
+ {
(*this) = count;
}
inline bool operator==(const Vertex45CountT& count) const {
@@ -612,7 +628,7 @@
//std::cout << "case2: " << i << " " << j << std::endl;
//std::cout << "creating active tail pair\n";
std::pair<ActiveTail45*, ActiveTail45*> tailPair =
- ActiveTail45::createActiveTail45sAsPair(point, true, 0, fractureHoles_);
+ ActiveTail45::createActiveTail45sAsPair(point, true, 0, fractureHoles_ != 0);
//tailPair.first->print();
//tailPair.second->print();
if(j == 3) {
@@ -730,7 +746,7 @@
ActiveTail45* holep = 0;
if(counts[3] == 0) holep = tails[3];
std::pair<ActiveTail45*, ActiveTail45*> tailPair =
- ActiveTail45::createActiveTail45sAsPair(point, false, holep, fractureHoles_);
+ ActiveTail45::createActiveTail45sAsPair(point, false, holep, fractureHoles_ != 0);
if(j == 3) {
returnValue = tailPair.first;
returnCount = -1;
Modified: sandbox/gtl/boost/polygon/detail/polygon_45_set_view.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/detail/polygon_45_set_view.hpp (original)
+++ sandbox/gtl/boost/polygon/detail/polygon_45_set_view.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -38,6 +38,9 @@
value_type rinput_;
rinput_.set(polygon_45_set_traits<rtype>::begin(rvalue_),
polygon_45_set_traits<rtype>::end(rvalue_));
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (disable: 4127)
+#endif
if(op_type == 0)
output_ |= rinput_;
else if(op_type == 1)
@@ -46,6 +49,9 @@
output_ ^= rinput_;
else
output_ -= rinput_;
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (default: 4127)
+#endif
}
};
@@ -55,6 +61,9 @@
void value(value_type& output_, const ltype& lvalue_, const polygon_45_set_data<rcoord>& rvalue_) {
output_.set(polygon_45_set_traits<ltype>::begin(lvalue_),
polygon_45_set_traits<ltype>::end(lvalue_));
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (disable: 4127)
+#endif
if(op_type == 0)
output_ |= rvalue_;
else if(op_type == 1)
@@ -63,6 +72,9 @@
output_ ^= rvalue_;
else
output_ -= rvalue_;
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (default: 4127)
+#endif
}
};
@@ -78,6 +90,8 @@
const rtype& rvalue_;
mutable value_type output_;
mutable bool evaluated_;
+
+ polygon_45_set_view& operator=(const polygon_45_set_view&);
public:
polygon_45_set_view(const ltype& lvalue,
const rtype& rvalue ) :
@@ -138,6 +152,9 @@
polygon_45_set_traits<ltype>::end(lvalue_));
rinput_.set(polygon_45_set_traits<rtype>::begin(rvalue_),
polygon_45_set_traits<rtype>::end(rvalue_));
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (disable: 4127)
+#endif
if(op_type == 0)
output_ |= rinput_;
else if(op_type == 1)
@@ -146,6 +163,9 @@
output_ ^= rinput_;
else
output_ -= rinput_;
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (default: 4127)
+#endif
polygon_45_set_mutable_traits<geometry_type_1>::set(lvalue_, output_.begin(), output_.end());
return lvalue_;
}
Modified: sandbox/gtl/boost/polygon/detail/polygon_45_touch.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/detail/polygon_45_touch.hpp (original)
+++ sandbox/gtl/boost/polygon/detail/polygon_45_touch.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -128,7 +128,7 @@
struct touch_45_output_functor {
template <typename cT>
void operator()(cT& output, const CountTouch& count1, const CountTouch& count2,
- const Point& pt, int rise, direction_1d end) {
+ const Point& pt, int , direction_1d ) {
Unit& x = output.first.first;
std::map<Unit, std::set<int> >& y_prop_map = output.first.second;
if(pt.x() != x) process_previous_x(output);
Modified: sandbox/gtl/boost/polygon/detail/polygon_90_set_view.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/detail/polygon_90_set_view.hpp (original)
+++ sandbox/gtl/boost/polygon/detail/polygon_90_set_view.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -50,7 +50,7 @@
struct compute_90_set_value<value_type, polygon_90_set_data<lcoord>, polygon_90_set_data<rcoord>, op_type> {
static
void value(value_type& output_, const polygon_90_set_data<lcoord>& lvalue_,
- const polygon_90_set_data<rcoord>& rvalue_, orientation_2d orient_) {
+ const polygon_90_set_data<rcoord>& rvalue_, orientation_2d) {
lvalue_.sort();
rvalue_.sort();
output_.applyBooleanBinaryOp(lvalue_.begin(), lvalue_.end(),
@@ -98,6 +98,7 @@
op_type op_;
mutable value_type output_;
mutable bool evaluated_;
+ polygon_90_set_view& operator=(const polygon_90_set_view&);
public:
polygon_90_set_view(const ltype& lvalue,
const rtype& rvalue,
Modified: sandbox/gtl/boost/polygon/detail/polygon_arbitrary_formation.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/detail/polygon_arbitrary_formation.hpp (original)
+++ sandbox/gtl/boost/polygon/detail/polygon_arbitrary_formation.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -220,7 +220,7 @@
elm1.second.get(VERTICAL) - elm1.first.get(VERTICAL),
elm2.second.get(HORIZONTAL) - elm2.first.get(HORIZONTAL),
elm2.second.get(VERTICAL) - elm2.first.get(VERTICAL));
- return (*justBefore_) ^ result;
+ return ((*justBefore_) != 0) ^ result;
}
return false;
}
@@ -533,7 +533,7 @@
elm1.other_pt.get(VERTICAL) - elm1.pt.get(VERTICAL),
elm2.other_pt.get(HORIZONTAL) - elm2.pt.get(HORIZONTAL),
elm2.other_pt.get(VERTICAL) - elm2.pt.get(VERTICAL));
- return (*justBefore_) ^ result;
+ return ((*justBefore_) != 0) ^ result;
}
return false;
}
@@ -1150,7 +1150,7 @@
//std::cout << "case2: " << i << " " << j << std::endl;
//std::cout << "creating active tail pair\n";
std::pair<active_tail_arbitrary*, active_tail_arbitrary*> tailPair =
- active_tail_arbitrary::createActiveTailsAsPair(point, true, 0, fractureHoles_);
+ active_tail_arbitrary::createActiveTailsAsPair(point, true, 0, fractureHoles_ != 0);
//tailPair.first->print();
//tailPair.second->print();
if(j == i_size_less_1 && incoming_count[j].first.get(HORIZONTAL) == point.get(HORIZONTAL)) {
@@ -1296,7 +1296,7 @@
have_vertical_tail_from_below = false;
}
std::pair<active_tail_arbitrary*, active_tail_arbitrary*> tailPair =
- active_tail_arbitrary::createActiveTailsAsPair(point, false, holep, fractureHoles_);
+ active_tail_arbitrary::createActiveTailsAsPair(point, false, holep, fractureHoles_ != 0);
if(j == i_size_less_1 && incoming_count[j].first.get(HORIZONTAL) == point.get(HORIZONTAL)) {
//std::cout << "vertical element " << point << std::endl;
returnValue = tailPair.first;
@@ -2090,7 +2090,7 @@
//std::cout << "case2: " << i << " " << j << std::endl;
//std::cout << "creating active tail pair\n";
std::pair<active_tail_arbitrary*, active_tail_arbitrary*> tailPair =
- active_tail_arbitrary::createActiveTailsAsPair(point, true, 0, polygon_arbitrary_formation<Unit>::fractureHoles_);
+ active_tail_arbitrary::createActiveTailsAsPair(point, true, 0, polygon_arbitrary_formation<Unit>::fractureHoles_ != 0);
//tailPair.first->print();
//tailPair.second->print();
if(j == i_size_less_1 && incoming_count[j].first.get(HORIZONTAL) == point.get(HORIZONTAL)) {
Modified: sandbox/gtl/boost/polygon/detail/polygon_formation.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/detail/polygon_formation.hpp (original)
+++ sandbox/gtl/boost/polygon/detail/polygon_formation.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -1719,7 +1719,7 @@
//public API to access polygon formation algorithm
template <typename output_container, typename iterator_type, typename concept_type>
unsigned int get_polygons(output_container& container, iterator_type begin, iterator_type end,
- orientation_2d orient, bool fracture_holes, concept_type tag) {
+ orientation_2d orient, bool fracture_holes, concept_type ) {
typedef typename output_container::value_type polygon_type;
typedef typename iterator_type::value_type::first_type coordinate_type;
polygon_type poly;
Modified: sandbox/gtl/boost/polygon/detail/polygon_set_view.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/detail/polygon_set_view.hpp (original)
+++ sandbox/gtl/boost/polygon/detail/polygon_set_view.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -68,24 +68,23 @@
static inline bool sort(const polygon_set_view<ltype, rtype, op_type>& polygon_set);
};
- template <typename value_type, typename geometry_type_1, typename geometry_type_2, int op_type>
- void execute_boolean_op(value_type& output_, const geometry_type_1& lvalue_, const geometry_type_2& rvalue_,
- double coord) {
- typedef geometry_type_1 ltype;
- typedef geometry_type_2 rtype;
- typedef typename polygon_set_traits<ltype>::coordinate_type coordinate_type;
- value_type linput_;
- value_type rinput_;
- insert_into_view_arg(linput_, lvalue_);
- insert_into_view_arg(rinput_, rvalue_);
- arbitrary_boolean_op<coordinate_type> abo;
- abo.execute(output_, linput_.begin(), linput_.end(),
- rinput_.begin(), rinput_.end(), op_type);
- }
+ //template <typename value_type, typename geometry_type_1, typename geometry_type_2, int op_type>
+ //void execute_boolean_op(value_type& output_, const geometry_type_1& lvalue_, const geometry_type_2& rvalue_,
+ // double coord) {
+ // typedef geometry_type_1 ltype;
+ // typedef geometry_type_2 rtype;
+ // typedef typename polygon_set_traits<ltype>::coordinate_type coordinate_type;
+ // value_type linput_;
+ // value_type rinput_;
+ // insert_into_view_arg(linput_, lvalue_);
+ // insert_into_view_arg(rinput_, rvalue_);
+ // arbitrary_boolean_op<coordinate_type> abo;
+ // abo.execute(output_, linput_.begin(), linput_.end(),
+ // rinput_.begin(), rinput_.end(), op_type);
+ //}
template <typename value_type, typename geometry_type_1, typename geometry_type_2, int op_type>
- void execute_boolean_op(value_type& output_, const geometry_type_1& lvalue_, const geometry_type_2& rvalue_,
- int coord) {
+ void execute_boolean_op(value_type& output_, const geometry_type_1& lvalue_, const geometry_type_2& rvalue_) {
typedef geometry_type_1 ltype;
typedef geometry_type_2 rtype;
typedef typename polygon_set_traits<ltype>::coordinate_type coordinate_type;
@@ -96,12 +95,18 @@
polygon_45_set_data<coordinate_type> l45, r45, o45;
if(linput_.downcast(l45) && rinput_.downcast(r45)) {
//the op codes are screwed up between 45 and arbitrary
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (disable: 4127)
+#endif
if(op_type < 2)
l45.template applyAdaptiveBoolean_<op_type>(o45, r45);
else if(op_type == 2)
l45.template applyAdaptiveBoolean_<3>(o45, r45);
else
l45.template applyAdaptiveBoolean_<2>(o45, r45);
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (default: 4127)
+#endif
output_.insert(o45);
} else {
arbitrary_boolean_op<coordinate_type> abo;
@@ -122,6 +127,7 @@
const rtype& rvalue_;
mutable value_type output_;
mutable bool evaluated_;
+ polygon_set_view& operator=(const polygon_set_view&);
public:
polygon_set_view(const ltype& lvalue,
const rtype& rvalue ) :
@@ -132,7 +138,7 @@
const value_type& value() const {
if(!evaluated_) {
evaluated_ = true;
- execute_boolean_op<value_type, ltype, rtype, op_type>(output_, lvalue_, rvalue_, coordinate_type());
+ execute_boolean_op<value_type, ltype, rtype, op_type>(output_, lvalue_, rvalue_);
}
return output_;
}
@@ -160,11 +166,11 @@
}
template <typename ltype, typename rtype, int op_type>
bool polygon_set_traits<polygon_set_view<ltype, rtype, op_type> >::
- clean(const polygon_set_view<ltype, rtype, op_type>& polygon_set) {
+ clean(const polygon_set_view<ltype, rtype, op_type>& ) {
return true; }
template <typename ltype, typename rtype, int op_type>
bool polygon_set_traits<polygon_set_view<ltype, rtype, op_type> >::
- sort(const polygon_set_view<ltype, rtype, op_type>& polygon_set) {
+ sort(const polygon_set_view<ltype, rtype, op_type>& ) {
return true; }
template <typename value_type, typename arg_type>
@@ -182,7 +188,7 @@
typedef typename polygon_set_traits<ltype>::coordinate_type coordinate_type;
typedef polygon_set_data<coordinate_type> value_type;
value_type output_;
- execute_boolean_op<value_type, geometry_type_1, geometry_type_2, op_type>(output_, lvalue_, rvalue_, coordinate_type());
+ execute_boolean_op<value_type, geometry_type_1, geometry_type_2, op_type>(output_, lvalue_, rvalue_);
polygon_set_mutable_traits<geometry_type_1>::set(lvalue_, output_.begin(), output_.end());
return lvalue_;
}
Modified: sandbox/gtl/boost/polygon/detail/rectangle_formation.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/detail/rectangle_formation.hpp (original)
+++ sandbox/gtl/boost/polygon/detail/rectangle_formation.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -240,7 +240,7 @@
template <typename output_container, typename iterator_type, typename rectangle_concept>
void form_rectangles(output_container& output, iterator_type begin, iterator_type end,
- orientation_2d orient, rectangle_concept tag) {
+ orientation_2d orient, rectangle_concept ) {
typedef typename output_container::value_type rectangle_type;
typedef typename get_coordinate_type_for_rectangles<rectangle_type, typename geometry_concept<rectangle_type>::type>::type Unit;
rectangle_data<Unit> model;
Modified: sandbox/gtl/boost/polygon/detail/scan_arbitrary.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/detail/scan_arbitrary.hpp (original)
+++ sandbox/gtl/boost/polygon/detail/scan_arbitrary.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -210,7 +210,7 @@
template <typename iT>
static inline void segment_edge(std::vector<std::pair<half_edge, int> >& output_segments,
- const half_edge& he, segment_id id, iT begin, iT end) {
+ const half_edge& , segment_id id, iT begin, iT end) {
iT current = begin;
iT next = begin;
++next;
@@ -750,13 +750,14 @@
return true;
}
- static void print(const std::pair<half_edge, segment_id>& segment) {
+ //static void print(const std::pair<half_edge, segment_id>& segment) {
//std::cout << segment.first.first << " " << segment.first.second << ": " << segment.second << "; ";
- }
+ //}
static void print(const std::vector<std::pair<half_edge, segment_id> >& vec) {
- //for(std::size_t i = 0; i < vec.size(); ++ i) {
+ for(std::size_t i = 0; i < vec.size(); ++ i) {
// print(vec[i]);
- //} std::cout << std::endl;
+ }
+ //std::cout << std::endl;
}
template <typename stream_type>
@@ -916,6 +917,9 @@
high_precision y = (high_precision)((std::numeric_limits<Unit>::min)());
bool first_iteration = true;
//we want to return from inside the loop when we hit end or new x
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning( disable: 4127 )
+#endif
while(true) {
if(begin == end || (!first_iteration && (high_precision)(((*begin).first.first.get(VERTICAL)) != y ||
(*begin).first.first.get(HORIZONTAL) != x_))) {
@@ -1016,6 +1020,10 @@
++begin;
}
}
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning( default: 4127 )
+#endif
+
}
inline void erase_end_events(typename end_point_queue::iterator epqi) {
@@ -1454,7 +1462,7 @@
protected:
template <typename polygon_type>
void insert(const polygon_type& polygon_object, const property_type& property_value, bool is_hole,
- polygon_concept tag) {
+ polygon_concept ) {
bool first_iteration = true;
bool second_iteration = true;
Point first_point;
@@ -1477,7 +1485,7 @@
}
} else {
if(previous_point != current_point) {
- create_vertex(pmd, previous_previous_point, previous_point, current_point, winding_dir,
+ create_vertex(pmd, previous_point, current_point, winding_dir,
is_hole, property_value);
previous_previous_point = previous_point;
previous_point = current_point;
@@ -1487,13 +1495,13 @@
current_point = first_point;
if(!first_iteration && !second_iteration) {
if(previous_point != current_point) {
- create_vertex(pmd, previous_previous_point, previous_point, current_point, winding_dir,
+ create_vertex(pmd, previous_point, current_point, winding_dir,
is_hole, property_value);
previous_previous_point = previous_point;
previous_point = current_point;
}
current_point = second_point;
- create_vertex(pmd, previous_previous_point, previous_point, current_point, winding_dir,
+ create_vertex(pmd, previous_point, current_point, winding_dir,
is_hole, property_value);
previous_previous_point = previous_point;
previous_point = current_point;
@@ -1513,7 +1521,7 @@
template <typename rectangle_type>
void insert(const rectangle_type& rectangle_object, const property_type& property_value, bool is_hole,
- rectangle_concept tag) {
+ rectangle_concept ) {
polygon_90_data<Unit> poly;
assign(poly, rectangle_object);
insert(poly, property_value, is_hole, polygon_concept());
@@ -1522,7 +1530,6 @@
public: //change to private when done testing
static inline void create_vertex(property_merge_data& pmd,
- const Point& previous_point,
const Point& current_point,
const Point& next_point,
direction_1d winding,
@@ -2399,6 +2406,9 @@
elem.second = 1;
if(edge.second < edge.first) elem.second *= -1;
if(is_vertical(edge)) elem.second *= -1;
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (disable: 4127)
+#endif
if(op_type == 0) { //OR
if(!left.empty() && right.empty()) {
result.insert_clean(elem);
@@ -2426,6 +2436,9 @@
result.insert_clean(elem);
}
}
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (default: 4127)
+#endif
if(right.size() == 1) {
if((*(right.begin())) == 0) {
elem.second *= -1;
Modified: sandbox/gtl/boost/polygon/detail/transform_detail.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/detail/transform_detail.hpp (original)
+++ sandbox/gtl/boost/polygon/detail/transform_detail.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -108,18 +108,18 @@
}
inline axis_transformation& axis_transformation::operator+=(const axis_transformation& a){
- bool abit5 = a.atr_ & 32;
- bool abit4 = a.atr_ & 16;
- bool abit3 = a.atr_ & 8;
- bool abit2 = a.atr_ & 4;
- bool abit1 = a.atr_ & 2;
- bool abit0 = a.atr_ & 1;
- bool bit5 = atr_ & 32;
- bool bit4 = atr_ & 16;
- bool bit3 = atr_ & 8;
- bool bit2 = atr_ & 4;
- bool bit1 = atr_ & 2;
- bool bit0 = atr_ & 1;
+ bool abit5 = (a.atr_ & 32) != 0;
+ bool abit4 = (a.atr_ & 16) != 0;
+ bool abit3 = (a.atr_ & 8) != 0;
+ bool abit2 = (a.atr_ & 4) != 0;
+ bool abit1 = (a.atr_ & 2) != 0;
+ bool abit0 = (a.atr_ & 1) != 0;
+ bool bit5 = (atr_ & 32) != 0;
+ bool bit4 = (atr_ & 16) != 0;
+ bool bit3 = (atr_ & 8) != 0;
+ bool bit2 = (atr_ & 4) != 0;
+ bool bit1 = (atr_ & 2) != 0;
+ bool bit0 = (atr_ & 1) != 0;
int indexes[2][3] = {
{
((int)((bit5 & bit2) | (bit4 & !bit2)) << 1) +
@@ -169,12 +169,12 @@
// populate_axis_array writes the three INDIVIDUAL_AXIS values that the
// ATR enum value of 'this' represent into axis_array
inline void axis_transformation::populate_axis_array(INDIVIDUAL_AXIS axis_array[]) const {
- bool bit5 = atr_ & 32;
- bool bit4 = atr_ & 16;
- bool bit3 = atr_ & 8;
- bool bit2 = atr_ & 4;
- bool bit1 = atr_ & 2;
- bool bit0 = atr_ & 1;
+ bool bit5 = (atr_ & 32) != 0;
+ bool bit4 = (atr_ & 16) != 0;
+ bool bit3 = (atr_ & 8) != 0;
+ bool bit2 = (atr_ & 4) != 0;
+ bool bit1 = (atr_ & 2) != 0;
+ bool bit0 = (atr_ & 1) != 0;
axis_array[2] =
(INDIVIDUAL_AXIS)((((int)(!bit4 & !bit5)) << 2) +
((int)(bit5) << 1) +
@@ -221,11 +221,11 @@
// write_back_axis_array converts an array of three INDIVIDUAL_AXIS values
// to the ATR enum value and sets 'this' to that value
inline void axis_transformation::write_back_axis_array(const INDIVIDUAL_AXIS this_array[]) {
- int bit5 = (bool)((int)this_array[2] & 2);
- int bit4 = !((bool)((int)this_array[2] & 4) | (bool)((int)this_array[2] & 2));
- int bit3 = (bool)((int)this_array[2] & 1);
+ int bit5 = ((int)this_array[2] & 2) != 0;
+ int bit4 = !((((int)this_array[2] & 4) != 0) | (((int)this_array[2] & 2) != 0));
+ int bit3 = ((int)this_array[2] & 1) != 0;
//bit 2 is the tricky bit
- int bit2 = (!(bit5 | bit4) & (bool)((int)this_array[0] & 2)) | //swap xy
+ int bit2 = ((!(bit5 | bit4)) & (((int)this_array[0] & 2) != 0)) | //swap xy
(bit5 & (((int)this_array[0] & 4) >> 2)) | //z->y x->z
(bit4 & (((int)this_array[1] & 4) >> 2)); //z->x y->z
int bit1 = ((int)this_array[1] & 1);
@@ -242,7 +242,7 @@
inline axis_transformation&
axis_transformation::set_directions(const direction_2d& horizontalDir,
const direction_2d& verticalDir){
- int bit2 = bool(static_cast<orientation_2d>(horizontalDir).to_int());
+ int bit2 = (static_cast<orientation_2d>(horizontalDir).to_int()) != 0;
int bit1 = !(verticalDir.to_int() & 1);
int bit0 = !(horizontalDir.to_int() & 1);
atr_ = ATR((bit2 << 2) + (bit1 << 1) + bit0);
@@ -257,11 +257,11 @@
int this_array[3] = {horizontalDir.to_int(),
verticalDir.to_int(),
proximalDir.to_int()};
- int bit5 = (bool)(this_array[2] & 2);
- int bit4 = !((bool)(this_array[2] & 4) | (bool)(this_array[2] & 2));
- int bit3 = !(bool)(this_array[2] & 1);
+ int bit5 = (this_array[2] & 2) != 0;
+ int bit4 = !(((this_array[2] & 4) != 0) | ((this_array[2] & 2) != 0));
+ int bit3 = !((this_array[2] & 1) != 0);
//bit 2 is the tricky bit
- int bit2 = (!(bit5 | bit4) & (bool)(this_array[0] & 2)) | //swap xy
+ int bit2 = (!(bit5 | bit4) & ((this_array[0] & 2) != 0 )) | //swap xy
(bit5 & ((this_array[0] & 4) >> 2)) | //z->y x->z
(bit4 & ((this_array[1] & 4) >> 2)); //z->x y->z
int bit1 = !(this_array[1] & 1);
@@ -276,36 +276,36 @@
template <typename coordinate_type_2>
inline void axis_transformation::transform(coordinate_type_2& x, coordinate_type_2& y) const {
- int bit2 = (bool)(atr_ & 4);
- int bit1 = (bool)(atr_ & 2);
- int bit0 = (bool)(atr_ & 1);
+ int bit2 = (atr_ & 4) != 0;
+ int bit1 = (atr_ & 2) != 0;
+ int bit0 = (atr_ & 1) != 0;
x *= -((bit0 << 1) - 1);
y *= -((bit1 << 1) - 1);
- predicated_swap(bit2,x,y);
+ predicated_swap(bit2 != 0,x,y);
}
template <typename coordinate_type_2>
inline void axis_transformation::transform(coordinate_type_2& x, coordinate_type_2& y, coordinate_type_2& z) const {
- int bit5 = (bool)(atr_ & 32);
- int bit4 = (bool)(atr_ & 16);
- int bit3 = (bool)(atr_ & 8);
- int bit2 = (bool)(atr_ & 4);
- int bit1 = (bool)(atr_ & 2);
- int bit0 = (bool)(atr_ & 1);
+ int bit5 = (atr_ & 32) != 0;
+ int bit4 = (atr_ & 16) != 0;
+ int bit3 = (atr_ & 8) != 0;
+ int bit2 = (atr_ & 4) != 0;
+ int bit1 = (atr_ & 2) != 0;
+ int bit0 = (atr_ & 1) != 0;
x *= -((bit0 << 1) - 1);
y *= -((bit1 << 1) - 1);
z *= -((bit3 << 1) - 1);
- predicated_swap(bit2, x, y);
- predicated_swap(bit5, y, z);
- predicated_swap(bit4, x, z);
+ predicated_swap(bit2 != 0, x, y);
+ predicated_swap(bit5 != 0, y, z);
+ predicated_swap(bit4 != 0, x, z);
}
inline axis_transformation& axis_transformation::invert_2d() {
- int bit2 = (bool)(atr_ & 4);
- int bit1 = (bool)(atr_ & 2);
- int bit0 = (bool)(atr_ & 1);
+ int bit2 = ((atr_ & 4) != 0);
+ int bit1 = ((atr_ & 2) != 0);
+ int bit0 = ((atr_ & 1) != 0);
//swap bit 0 and bit 1 if bit2 is 1
- predicated_swap(bit2, bit0, bit1);
+ predicated_swap(bit2 != 0, bit0, bit1);
bit1 = bit1 << 1;
atr_ = (ATR)(atr_ & (32+16+8+4)); //mask away bit0 and bit1
atr_ = (ATR)(atr_ | bit0 | bit1);
@@ -318,16 +318,16 @@
}
inline axis_transformation& axis_transformation::invert() {
- int bit5 = (bool)(atr_ & 32);
- int bit4 = (bool)(atr_ & 16);
- int bit3 = (bool)(atr_ & 8);
- int bit2 = (bool)(atr_ & 4);
- int bit1 = (bool)(atr_ & 2);
- int bit0 = (bool)(atr_ & 1);
- predicated_swap(bit2, bit4, bit5);
- predicated_swap(bit4, bit0, bit3);
- predicated_swap(bit5, bit1, bit3);
- predicated_swap(bit2, bit0, bit1);
+ int bit5 = ((atr_ & 32) != 0);
+ int bit4 = ((atr_ & 16) != 0);
+ int bit3 = ((atr_ & 8) != 0);
+ int bit2 = ((atr_ & 4) != 0);
+ int bit1 = ((atr_ & 2) != 0);
+ int bit0 = ((atr_ & 1) != 0);
+ predicated_swap(bit2 != 0, bit4, bit5);
+ predicated_swap(bit4 != 0, bit0, bit3);
+ predicated_swap(bit5 != 0, bit1, bit3);
+ predicated_swap(bit2 != 0, bit0, bit1);
atr_ = (ATR)((bit5 << 5) +
(bit4 << 4) +
(bit3 << 3) +
Modified: sandbox/gtl/boost/polygon/gtl_boost_unit_test.cpp
==============================================================================
--- sandbox/gtl/boost/polygon/gtl_boost_unit_test.cpp (original)
+++ sandbox/gtl/boost/polygon/gtl_boost_unit_test.cpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -7,6 +7,7 @@
*/
#define BOOST_POLYGON_NO_DEPS
#include <iostream>
+//#include <boost/polygon/polygon.hpp>
#include "polygon.hpp"
namespace gtl = boost::polygon;
using namespace boost::polygon::operators;
@@ -179,10 +180,10 @@
template <typename T>
typename enable_if<typename is_polygon_90_set_type<T>::type, void>::type
- print_is_polygon_90_set_concept(const T& t) { std::cout << "is polygon 90 set concept\n"; }
+ print_is_polygon_90_set_concept(const T& ) { std::cout << "is polygon 90 set concept\n"; }
template <typename T>
typename enable_if<typename is_mutable_polygon_90_set_type<T>::type, void>::type
- print_is_mutable_polygon_90_set_concept(const T& t) { std::cout << "is mutable polygon 90 set concept\n"; }
+ print_is_mutable_polygon_90_set_concept(const T& ) { std::cout << "is mutable polygon 90 set concept\n"; }
namespace boolean_op {
//self contained unit test for BooleanOr algorithm
template <typename Unit>
@@ -769,24 +770,39 @@
bool testRectangle() {
rectangle_data<int> rect, rect2;
+#ifdef BOOST_POLYGON_MSVC
+ horizontal(rect, interval_data<int>(0, 10));
+ vertical(rect, interval_data<int>(20, 30));
+#else
horizontal(rect, interval_data<long long>(0, 10));
vertical(rect, interval_data<long long>(20, 30));
+#endif
xl(rect2, 0);
xh(rect2, 10);
yl(rect2, 20);
yh(rect2, 30);
if(euclidean_distance(rect, rect2) != 0) return false;
if(euclidean_distance(rect2, rect) != 0) return false;
+#ifdef BOOST_POLYGON_MSVC
+ set(rect, HORIZONTAL, interval_data<int>(0, 10));
+ if(!equivalence(horizontal(rect), interval_data<int>(0, 10))) return false;
+ if(!equivalence(vertical(rect2), interval_data<int>(20, 30))) return false;
+#else
set(rect, HORIZONTAL, interval_data<long long>(0, 10));
if(!equivalence(horizontal(rect), interval_data<long long>(0, 10))) return false;
if(!equivalence(vertical(rect2), interval_data<long long>(20, 30))) return false;
+#endif
if(xl(rect) != 0) return false;
if(xh(rect) != 10) return false;
if(yl(rect) != 20) return false;
if(yh(rect) != 30) return false;
move(rect, HORIZONTAL, 10);
if(xl(rect) != 10) return false;
+#ifdef BOOST_POLYGON_MSVC
+ set_points(rect, point_data<int>(0, 20), point_data<int>(10, 30));
+#else
set_points(rect, point_data<int>(0, 20), point_data<long long>(10, 30));
+#endif
if(xl(rect) != 0) return false;
convolve(rect, rect2);
if(xh(rect) != 20) return false;
@@ -795,7 +811,11 @@
reflected_convolve(rect, rect2);
reflected_deconvolve(rect, rect2);
if(!equivalence(rect, rect2)) return false;
+#ifdef BOOST_POLYGON_MSVC
+ convolve(rect, point_data<int>(100, 200));
+#else
convolve(rect, point_data<long long>(100, 200));
+#endif
if(xh(rect) != 110) return false;
deconvolve(rect, point_data<int>(100, 200));
if(!equivalence(rect, rect2)) return false;
@@ -975,8 +995,8 @@
typedef axis_transformation AxisTransform;
typedef transformation<int> Transform;
-int getRandomBool() {
- return rand()%2;
+bool getRandomBool() {
+ return rand()%2 != 0;
}
int getRandomInt() {
return rand()%6-2;
@@ -1800,105 +1820,105 @@
std::cout << polys[i] << std::endl;
}
-void testHandFloat() {
- using namespace gtl;
- double handcoords[] = {
-12375, 11050, 13175, 10200, 15825, 9275, 18750, 8525, 24150, 8300, 27575, 8400, 31775, 7800,
-35975, 7200, 41375, 4800, 42575, 4200, 43175, 4200, 47375, 2400, 49175, 1800, 51150, 2200,
-52275, 2825, 52625, 4150, 52375, 4975, 51575, 6000, 49275, 6850, 45700, 7950, 43175, 9600,
-39575, 10800, 37775, 12000, 37775, 12600, 37775, 13800, 38975, 14400, 41375, 14400, 45575, 13200,
-48600, 13000, 51575, 13200, 55175, 12600, 58775, 12600, 61175, 13200, 62375, 14400, 62550, 15700,
-61975, 16875, 60775, 17600, 60100, 17675, 58525, 17675, 56150, 17575, 52175, 18000, 47975, 18600,
-45575, 19200, 44375, 19200, 42675, 19325, 41600, 19775, 41600, 20500, 42100, 20825, 44975, 20400,
-48575, 20400, 52775, 21000, 53975, 21000, 57575, 21000, 62375, 21000, 65450, 22000, 66300, 23100,
-66100, 24550, 64750, 25925, 62975, 26400, 61175, 26400, 58775, 26400, 56025, 26050, 53450, 26025,
-50975, 26400, 48575, 26400, 46775, 26400, 43650, 26075, 41375, 26400, 40775, 27000, 40775, 27600,
-42225, 28650, 44375, 29400, 48575, 30000, 50975, 31200, 53975, 31800, 58775, 33000, 61200, 34300,
-62375, 35400, 62375, 37200, 61175, 38400, 60000, 38700, 57575, 38400, 54550, 37575, 50975, 36600,
-49075, 36125, 47750, 36125, 45700, 35425, 42350, 34350, 38900, 33775, 30575, 33000, 26975, 33600,
-25975, 34900, 26375, 36600, 28175, 38400, 30575, 40800, 32375, 43800, 33200, 46200, 33200, 48000,
-32650, 49300, 31425, 50000, 29950, 50125, 28825, 49375, 27575, 48000, 25825, 46000, 23975, 44100,
-22175, 42600, 19775, 39600, 17325, 37300, 14975, 34800, 13175, 31800, 10775, 29400, 9600, 27400,
-10175, 27000, 11375, 27600, 12575, 28800, 14375, 31800, 16175, 34800, 18575, 37200, 21575, 39000,
-22775, 40200, 23975, 41400, 24575, 42600, 26375, 44400, 28325, 46000, 29850, 46775, 31175, 46200,
-31550, 44575, 30575, 43200, 28775, 40800, 25775, 38400, 24575, 34800, 24750, 33175, 26975, 31800,
-29975, 31800, 33575, 31800, 37775, 32400, 39575, 33000, 41975, 33600, 45150, 34175, 46975, 34750,
-48575, 35400, 50975, 35400, 51575, 34800, 51875, 33725, 50775, 32575, 48575, 31800, 45750, 30875,
-43775, 30600, 41375, 29400, 38975, 28800, 35975, 28200, 34775, 27600, 34175, 27000, 34775, 25800,
-37175, 25200, 40175, 25200, 43175, 25200, 46775, 25200, 50975, 25425, 53375, 25200, 55175, 24600,
-55525, 23450, 53975, 22200, 52775, 22200, 49075, 21850, 45950, 21925, 40775, 21600, 37775, 21600,
-35150, 21350, 34325, 20950, 34175, 19800, 35975, 19200, 38375, 19200, 40750, 18900, 42575, 18600,
-44375, 18000, 47975, 17400, 50375, 17125, 52025, 16625, 52775, 15600, 52100, 14625, 49675, 14125,
-48625, 14125, 46775, 14400, 44375, 15000, 41375, 15150, 37700, 15275, 34775, 15600, 32850, 15925,
-31775, 15600, 31425, 14875, 32375, 13800, 36575, 11400, 38975, 10200, 41375, 9000, 43075, 8150,
-43650, 7200, 43325, 6250, 42225, 5825, 40800, 6275, 38900, 6925, 35375, 8400, 32375, 10200,
-27575, 11400, 22775, 12600, 19775, 13225, 16775, 13800, 14975, 14400, 13050, 14000, 11975, 12600,
- 0, 0 };
- std::vector<point_data<double> > handpoints;
- for(unsigned int i = 0; i < 100000; i += 2) {
- point_data<double> pt(handcoords[i], handcoords[i+1]);
- if(pt == point_data<double> (0, 0)) break;
- handpoints.push_back(pt);
- }
- polygon_data<double> handpoly;
- handpoly.set(handpoints.begin(), handpoints.end());
- double spiralcoords [] = {
-37200, 3600, 42075, 4025, 47475, 5875, 51000, 7800, 55800, 12300, 59000, 17075, 60000, 20400,
-61200, 25800, 61200, 29400, 60600, 33600, 58800, 38400, 55800, 42600, 53200, 45625,
-49200, 48600, 43200, 51000, 35400, 51600, 29400, 50400, 23400, 47400, 19200, 43800,
-16200, 39600, 14400, 35400, 13200, 29400, 13200, 24000, 15000, 18600, 17400, 13800,
-20525, 10300, 24600, 7200, 29400, 4800, 32450, 4000, 34825, 3675, 35625, 3625,
-35825, 7275, 39600, 7200, 43800, 8400, 46800, 9600, 50400, 12000, 53400, 15000,
-55800, 18600, 57000, 23400, 57600, 27000, 57000, 32400, 55200, 37200, 52200, 41400,
-48000, 45000, 42000, 47400, 35400, 48000, 30000, 46800, 24600, 43800, 20325, 39100,
-17850, 34275, 16800, 27600, 17400, 22200, 20400, 16200, 24600, 11400, 28800, 9000,
-32400, 7800, 33200, 7575, 33925, 11050, 35400, 10800, 37200, 10800, 41400, 11400,
-46200, 13200, 49800, 16200, 51600, 19200, 53400, 23400, 54000, 29400, 52800, 33600,
-49800, 39000, 45000, 42600, 39000, 44400, 33600, 43800, 28200, 42000, 24000, 37800,
-21000, 33000, 20400, 26400, 21600, 21000, 24600, 16200, 28200, 13200, 31875, 11625,
-33200, 15625, 36000, 15000, 39000, 15000, 43800, 16800, 46800, 19200, 49200, 23400,
-49800, 27600, 48750, 32700, 46350, 36275, 42600, 39000, 38400, 40200, 31800, 39000,
-28200, 36600, 25200, 31200, 24600, 26400, 26025, 21800, 28200, 18600, 30600, 16800,
-32575, 19875, 34200, 19200, 36000, 18600, 37200, 18600, 40375, 19125, 43200, 21000,
-45600, 24000, 46200, 27600, 45600, 30600, 43800, 33600, 41475, 35625, 37800, 36600,
-33600, 36000, 30000, 33600, 28200, 28800, 28800, 24600, 30000, 22200, 31200, 23400,
-30600, 25200, 30000, 27000, 30600, 30000, 31800, 32400, 34200, 34200, 38400, 34800,
-41400, 33000, 44025, 30225, 44400, 26400, 43200, 23400, 40900, 21200, 37800, 20400,
-34950, 20675, 32400, 22200, 30175, 19475, 28425, 21300, 27000, 24000, 26400, 27600,
-27000, 31800, 31200, 36600, 36600, 38400, 42600, 37200, 46200, 33600, 48000, 30000,
-47650, 24425, 45600, 20400, 42650, 18200, 39000, 16800, 35400, 16800, 33600, 17400,
-32875, 17675, 31100, 13850, 28200, 15600, 25200, 18600, 22800, 22800, 22200, 27000,
-23400, 33600, 26400, 38400, 31675, 41575, 37800, 42600, 40850, 42150, 42800, 41550,
-47050, 39025, 50100, 35375, 52200, 29400, 51675, 23950, 49800, 19200, 46200, 15600,
-41400, 13200, 37800, 12600, 35025, 12750, 33350, 13050, 32400, 9600, 30025, 10325,
-25925, 12725, 22200, 16800, 19800, 21000, 18600, 25800, 18600, 30000, 20400, 35400,
-22575, 39250, 25225, 41825, 28200, 43800, 33600, 46200, 39000, 46200, 44400, 45000,
-48650, 42350, 52800, 37800, 55200, 32400, 55800, 26400, 54600, 21000, 53400, 18000,
-50400, 14400, 47400, 12000, 42600, 9600, 39000, 9000, 36000, 9000, 34775, 9125,
-34300, 5600, 30000, 6600, 25800, 8400, 22025, 11350, 18725, 15125, 16200, 20400,
-15000, 24600, 15000, 30600, 16800, 36600, 20400, 42600, 25800, 46800, 31200, 49200,
-38400, 49800, 45000, 48600, 51000, 45000, 55475, 40225, 58200, 34800, 59400, 30000,
-59400, 25200, 58200, 19800, 55200, 14400, 52225, 11150, 47400, 7800, 44175, 6500,
-40200, 5400, 38400, 5400, 37200, 5400, 0, 0 };
- std::vector<point_data<double> > spiralpoints;
- for(unsigned int i = 0; i < 100000; i += 2) {
- point_data<double> pt(spiralcoords[i], spiralcoords[i+1]);
- if(pt == point_data<double> (0, 0)) break;
- spiralpoints.push_back(pt);
- }
- polygon_data<double> spiralpoly;
- spiralpoly.set(spiralpoints.begin(), spiralpoints.end());
- polygon_set_data<double> handset;
- handset += handpoly;
- polygon_set_data<double> spiralset;
- spiralset += spiralpoly;
- polygon_set_data<double> xorset = handset ^ spiralset;
- std::vector<polygon_data<double> > polys;
- polys += xorset;
- std::cout << polys.size() << std::endl;
- for(unsigned int i = 0; i < polys.size(); ++i)
- std::cout << polys[i] << std::endl;
-}
+//void testHandFloat() {
+// using namespace gtl;
+// double handcoords[] = {
+//12375, 11050, 13175, 10200, 15825, 9275, 18750, 8525, 24150, 8300, 27575, 8400, 31775, 7800,
+//35975, 7200, 41375, 4800, 42575, 4200, 43175, 4200, 47375, 2400, 49175, 1800, 51150, 2200,
+//52275, 2825, 52625, 4150, 52375, 4975, 51575, 6000, 49275, 6850, 45700, 7950, 43175, 9600,
+//39575, 10800, 37775, 12000, 37775, 12600, 37775, 13800, 38975, 14400, 41375, 14400, 45575, 13200,
+//48600, 13000, 51575, 13200, 55175, 12600, 58775, 12600, 61175, 13200, 62375, 14400, 62550, 15700,
+//61975, 16875, 60775, 17600, 60100, 17675, 58525, 17675, 56150, 17575, 52175, 18000, 47975, 18600,
+//45575, 19200, 44375, 19200, 42675, 19325, 41600, 19775, 41600, 20500, 42100, 20825, 44975, 20400,
+//48575, 20400, 52775, 21000, 53975, 21000, 57575, 21000, 62375, 21000, 65450, 22000, 66300, 23100,
+//66100, 24550, 64750, 25925, 62975, 26400, 61175, 26400, 58775, 26400, 56025, 26050, 53450, 26025,
+//50975, 26400, 48575, 26400, 46775, 26400, 43650, 26075, 41375, 26400, 40775, 27000, 40775, 27600,
+//42225, 28650, 44375, 29400, 48575, 30000, 50975, 31200, 53975, 31800, 58775, 33000, 61200, 34300,
+//62375, 35400, 62375, 37200, 61175, 38400, 60000, 38700, 57575, 38400, 54550, 37575, 50975, 36600,
+//49075, 36125, 47750, 36125, 45700, 35425, 42350, 34350, 38900, 33775, 30575, 33000, 26975, 33600,
+//25975, 34900, 26375, 36600, 28175, 38400, 30575, 40800, 32375, 43800, 33200, 46200, 33200, 48000,
+//32650, 49300, 31425, 50000, 29950, 50125, 28825, 49375, 27575, 48000, 25825, 46000, 23975, 44100,
+//22175, 42600, 19775, 39600, 17325, 37300, 14975, 34800, 13175, 31800, 10775, 29400, 9600, 27400,
+//10175, 27000, 11375, 27600, 12575, 28800, 14375, 31800, 16175, 34800, 18575, 37200, 21575, 39000,
+//22775, 40200, 23975, 41400, 24575, 42600, 26375, 44400, 28325, 46000, 29850, 46775, 31175, 46200,
+//31550, 44575, 30575, 43200, 28775, 40800, 25775, 38400, 24575, 34800, 24750, 33175, 26975, 31800,
+//29975, 31800, 33575, 31800, 37775, 32400, 39575, 33000, 41975, 33600, 45150, 34175, 46975, 34750,
+//48575, 35400, 50975, 35400, 51575, 34800, 51875, 33725, 50775, 32575, 48575, 31800, 45750, 30875,
+//43775, 30600, 41375, 29400, 38975, 28800, 35975, 28200, 34775, 27600, 34175, 27000, 34775, 25800,
+//37175, 25200, 40175, 25200, 43175, 25200, 46775, 25200, 50975, 25425, 53375, 25200, 55175, 24600,
+//55525, 23450, 53975, 22200, 52775, 22200, 49075, 21850, 45950, 21925, 40775, 21600, 37775, 21600,
+//35150, 21350, 34325, 20950, 34175, 19800, 35975, 19200, 38375, 19200, 40750, 18900, 42575, 18600,
+//44375, 18000, 47975, 17400, 50375, 17125, 52025, 16625, 52775, 15600, 52100, 14625, 49675, 14125,
+//48625, 14125, 46775, 14400, 44375, 15000, 41375, 15150, 37700, 15275, 34775, 15600, 32850, 15925,
+//31775, 15600, 31425, 14875, 32375, 13800, 36575, 11400, 38975, 10200, 41375, 9000, 43075, 8150,
+//43650, 7200, 43325, 6250, 42225, 5825, 40800, 6275, 38900, 6925, 35375, 8400, 32375, 10200,
+//27575, 11400, 22775, 12600, 19775, 13225, 16775, 13800, 14975, 14400, 13050, 14000, 11975, 12600,
+// 0, 0 };
+// std::vector<point_data<double> > handpoints;
+// for(unsigned int i = 0; i < 100000; i += 2) {
+// point_data<double> pt(handcoords[i], handcoords[i+1]);
+// if(pt == point_data<double> (0, 0)) break;
+// handpoints.push_back(pt);
+// }
+// polygon_data<double> handpoly;
+// handpoly.set(handpoints.begin(), handpoints.end());
+// double spiralcoords [] = {
+//37200, 3600, 42075, 4025, 47475, 5875, 51000, 7800, 55800, 12300, 59000, 17075, 60000, 20400,
+//61200, 25800, 61200, 29400, 60600, 33600, 58800, 38400, 55800, 42600, 53200, 45625,
+//49200, 48600, 43200, 51000, 35400, 51600, 29400, 50400, 23400, 47400, 19200, 43800,
+//16200, 39600, 14400, 35400, 13200, 29400, 13200, 24000, 15000, 18600, 17400, 13800,
+//20525, 10300, 24600, 7200, 29400, 4800, 32450, 4000, 34825, 3675, 35625, 3625,
+//35825, 7275, 39600, 7200, 43800, 8400, 46800, 9600, 50400, 12000, 53400, 15000,
+//55800, 18600, 57000, 23400, 57600, 27000, 57000, 32400, 55200, 37200, 52200, 41400,
+//48000, 45000, 42000, 47400, 35400, 48000, 30000, 46800, 24600, 43800, 20325, 39100,
+//17850, 34275, 16800, 27600, 17400, 22200, 20400, 16200, 24600, 11400, 28800, 9000,
+//32400, 7800, 33200, 7575, 33925, 11050, 35400, 10800, 37200, 10800, 41400, 11400,
+//46200, 13200, 49800, 16200, 51600, 19200, 53400, 23400, 54000, 29400, 52800, 33600,
+//49800, 39000, 45000, 42600, 39000, 44400, 33600, 43800, 28200, 42000, 24000, 37800,
+//21000, 33000, 20400, 26400, 21600, 21000, 24600, 16200, 28200, 13200, 31875, 11625,
+//33200, 15625, 36000, 15000, 39000, 15000, 43800, 16800, 46800, 19200, 49200, 23400,
+//49800, 27600, 48750, 32700, 46350, 36275, 42600, 39000, 38400, 40200, 31800, 39000,
+//28200, 36600, 25200, 31200, 24600, 26400, 26025, 21800, 28200, 18600, 30600, 16800,
+//32575, 19875, 34200, 19200, 36000, 18600, 37200, 18600, 40375, 19125, 43200, 21000,
+//45600, 24000, 46200, 27600, 45600, 30600, 43800, 33600, 41475, 35625, 37800, 36600,
+//33600, 36000, 30000, 33600, 28200, 28800, 28800, 24600, 30000, 22200, 31200, 23400,
+//30600, 25200, 30000, 27000, 30600, 30000, 31800, 32400, 34200, 34200, 38400, 34800,
+//41400, 33000, 44025, 30225, 44400, 26400, 43200, 23400, 40900, 21200, 37800, 20400,
+//34950, 20675, 32400, 22200, 30175, 19475, 28425, 21300, 27000, 24000, 26400, 27600,
+//27000, 31800, 31200, 36600, 36600, 38400, 42600, 37200, 46200, 33600, 48000, 30000,
+//47650, 24425, 45600, 20400, 42650, 18200, 39000, 16800, 35400, 16800, 33600, 17400,
+//32875, 17675, 31100, 13850, 28200, 15600, 25200, 18600, 22800, 22800, 22200, 27000,
+//23400, 33600, 26400, 38400, 31675, 41575, 37800, 42600, 40850, 42150, 42800, 41550,
+//47050, 39025, 50100, 35375, 52200, 29400, 51675, 23950, 49800, 19200, 46200, 15600,
+//41400, 13200, 37800, 12600, 35025, 12750, 33350, 13050, 32400, 9600, 30025, 10325,
+//25925, 12725, 22200, 16800, 19800, 21000, 18600, 25800, 18600, 30000, 20400, 35400,
+//22575, 39250, 25225, 41825, 28200, 43800, 33600, 46200, 39000, 46200, 44400, 45000,
+//48650, 42350, 52800, 37800, 55200, 32400, 55800, 26400, 54600, 21000, 53400, 18000,
+//50400, 14400, 47400, 12000, 42600, 9600, 39000, 9000, 36000, 9000, 34775, 9125,
+//34300, 5600, 30000, 6600, 25800, 8400, 22025, 11350, 18725, 15125, 16200, 20400,
+//15000, 24600, 15000, 30600, 16800, 36600, 20400, 42600, 25800, 46800, 31200, 49200,
+//38400, 49800, 45000, 48600, 51000, 45000, 55475, 40225, 58200, 34800, 59400, 30000,
+//59400, 25200, 58200, 19800, 55200, 14400, 52225, 11150, 47400, 7800, 44175, 6500,
+//40200, 5400, 38400, 5400, 37200, 5400, 0, 0 };
+// std::vector<point_data<double> > spiralpoints;
+// for(unsigned int i = 0; i < 100000; i += 2) {
+// point_data<double> pt(spiralcoords[i], spiralcoords[i+1]);
+// if(pt == point_data<double> (0, 0)) break;
+// spiralpoints.push_back(pt);
+// }
+// polygon_data<double> spiralpoly;
+// spiralpoly.set(spiralpoints.begin(), spiralpoints.end());
+// polygon_set_data<double> handset;
+// handset += handpoly;
+// polygon_set_data<double> spiralset;
+// spiralset += spiralpoly;
+// polygon_set_data<double> xorset = handset ^ spiralset;
+// std::vector<polygon_data<double> > polys;
+// polys += xorset;
+// std::cout << polys.size() << std::endl;
+// for(unsigned int i = 0; i < polys.size(); ++i)
+// std::cout << polys[i] << std::endl;
+//}
bool testDirectionalSize() {
{
@@ -2229,7 +2249,7 @@
//max_cover_stress_test(); //does not include functional testing
if(!testDirectionalSize()) return 1;
testHand();
- testHandFloat();
+ //testHandFloat();
if(!testpip()) return 1;
{
PolygonSet ps;
Modified: sandbox/gtl/boost/polygon/interval_concept.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/interval_concept.hpp (original)
+++ sandbox/gtl/boost/polygon/interval_concept.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -242,10 +242,11 @@
typename interval_difference_type<interval_type>::type displacement,
typename enable_if<typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type * = 0
) {
- typedef typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::coordinate_difference Unit;
+ typedef typename interval_traits<interval_type>::coordinate_type ctype;
+ typedef typename coordinate_traits<ctype>::coordinate_difference Unit;
Unit len = delta(interval);
- low(interval, (Unit)low(interval) + displacement);
- high(interval, (Unit)low(interval) + len);
+ low(interval, static_cast<ctype>(static_cast<Unit>(low(interval)) + displacement));
+ high(interval, static_cast<ctype>(static_cast<Unit>(low(interval)) + len));
return interval;
}
Modified: sandbox/gtl/boost/polygon/interval_data.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/interval_data.hpp (original)
+++ sandbox/gtl/boost/polygon/interval_data.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -13,11 +13,23 @@
class interval_data {
public:
typedef T coordinate_type;
- inline interval_data():coords_(){}
- inline interval_data(coordinate_type low, coordinate_type high):coords_() {
+ inline interval_data()
+#ifndef BOOST_POLYGON_MSVC
+ :coords_()
+#endif
+ {}
+ inline interval_data(coordinate_type low, coordinate_type high)
+#ifndef BOOST_POLYGON_MSVC
+ :coords_()
+#endif
+ {
coords_[LOW] = low; coords_[HIGH] = high;
}
- inline interval_data(const interval_data& that):coords_() {
+ inline interval_data(const interval_data& that)
+#ifndef BOOST_POLYGON_MSVC
+ :coords_()
+#endif
+ {
(*this) = that;
}
inline interval_data& operator=(const interval_data& that) {
Modified: sandbox/gtl/boost/polygon/isotropy.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/isotropy.hpp (original)
+++ sandbox/gtl/boost/polygon/isotropy.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -28,7 +28,7 @@
#include <boost/config.hpp>
#ifdef BOOST_MSVC
-#define BOOST_POLYGON_WIN32
+#define BOOST_POLYGON_MSVC
#endif
#ifdef BOOST_INTEL
#define BOOST_POLYGON_ICC
@@ -47,7 +47,7 @@
#else
#ifdef WIN32
-#define BOOST_POLYGON_WIN32
+#define BOOST_POLYGON_MSVC
#endif
#ifdef __ICC
#define BOOST_POLYGON_ICC
Modified: sandbox/gtl/boost/polygon/point_3d_data.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/point_3d_data.hpp (original)
+++ sandbox/gtl/boost/polygon/point_3d_data.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -15,7 +15,11 @@
inline point_3d_data():coords_(){}
inline point_3d_data(coordinate_type x, coordinate_type y):coords_() {
coords_[HORIZONTAL] = x; coords_[VERTICAL] = y; coords_[PROXIMAL] = 0; }
- inline point_3d_data(coordinate_type x, coordinate_type y, coordinate_type z):coords_() {
+ inline point_3d_data(coordinate_type x, coordinate_type y, coordinate_type z)
+#ifndef BOOST_POLYGON_MSVC
+ :coords_()
+#endif
+ {
coords_[HORIZONTAL] = x; coords_[VERTICAL] = y; coords_[PROXIMAL] = z; }
inline point_3d_data(const point_3d_data& that):coords_() { (*this) = that; }
inline point_3d_data& operator=(const point_3d_data& that) {
Modified: sandbox/gtl/boost/polygon/point_data.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/point_data.hpp (original)
+++ sandbox/gtl/boost/polygon/point_data.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -16,11 +16,23 @@
class point_data {
public:
typedef T coordinate_type;
- inline point_data():coords_(){}
- inline point_data(coordinate_type x, coordinate_type y):coords_() {
+ inline point_data()
+#ifndef BOOST_POLYGON_MSVC
+ :coords_()
+#endif
+ {}
+ inline point_data(coordinate_type x, coordinate_type y)
+#ifndef BOOST_POLYGON_MSVC
+ :coords_()
+#endif
+ {
coords_[HORIZONTAL] = x; coords_[VERTICAL] = y;
}
- inline point_data(const point_data& that):coords_() { (*this) = that; }
+ inline point_data(const point_data& that)
+#ifndef BOOST_POLYGON_MSVC
+ :coords_()
+#endif
+ { (*this) = that; }
inline point_data& operator=(const point_data& that) {
coords_[0] = that.coords_[0]; coords_[1] = that.coords_[1]; return *this;
}
Modified: sandbox/gtl/boost/polygon/polygon_45_set_concept.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/polygon_45_set_concept.hpp (original)
+++ sandbox/gtl/boost/polygon/polygon_45_set_concept.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -197,7 +197,7 @@
polygon_set_type>::type &
bloat(polygon_set_type& polygon_set,
typename coordinate_traits<typename polygon_45_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type bloating) {
- return resize(polygon_set, bloating);
+ return resize(polygon_set, static_cast<typename polygon_45_set_traits<polygon_set_type>::coordinate_type>(bloating));
}
template <typename polygon_set_type>
Modified: sandbox/gtl/boost/polygon/polygon_45_set_data.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/polygon_45_set_data.hpp (original)
+++ sandbox/gtl/boost/polygon/polygon_45_set_data.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -18,7 +18,7 @@
enum CornerOption { INTERSECTION = 0, ORTHOGONAL = 1, UNFILLED = 2 };
template <typename ltype, typename rtype, int op_type>
- struct polygon_45_set_view;
+ class polygon_45_set_view;
struct polygon_45_set_concept {};
@@ -131,16 +131,20 @@
itr != polygon_set.end(); ++itr) {
Vertex45Compact vertex_45(point_data<Unit>((*itr).first, (*itr).second.first), 2, (*itr).second.second);
vertex_45.count[1] = (*itr).second.second;
- insert_clean(vertex_45);
+ if(is_hole) vertex_45.count[1] *= - 1;
+ insert_clean(vertex_45, is_hole);
}
} else {
for(typename polygon_90_set_data<coordinate_type_2>::iterator_type itr = polygon_set.begin();
itr != polygon_set.end(); ++itr) {
Vertex45Compact vertex_45(point_data<Unit>((*itr).second.first, (*itr).first), 2, (*itr).second.second);
vertex_45.count[1] = (*itr).second.second;
- insert_clean(vertex_45);
+ if(is_hole) vertex_45.count[1] *= - 1;
+ insert_clean(vertex_45, is_hole);
}
}
+ dirty_ = true;
+ unsorted_ = true;
}
template <typename output_container>
@@ -361,7 +365,7 @@
get_fracture(output, false, tag);
}
template <typename output_container, typename concept_type>
- void get_fracture(output_container& container, bool fracture_holes, concept_type tag) const {
+ void get_fracture(output_container& container, bool fracture_holes, concept_type ) const {
clean();
typename polygon_45_formation<Unit>::Polygon45Formation pf(fracture_holes);
//std::cout << "FORMING POLYGONS\n";
@@ -369,17 +373,17 @@
}
template <typename geometry_type>
- void insert_dispatch(const geometry_type& geometry_object, bool is_hole, undefined_concept tag) {
+ void insert_dispatch(const geometry_type& geometry_object, bool is_hole, undefined_concept) {
insert(geometry_object.begin(), geometry_object.end(), is_hole);
}
template <typename geometry_type>
void insert_dispatch(const geometry_type& geometry_object, bool is_hole, rectangle_concept tag);
template <typename geometry_type>
- void insert_dispatch(const geometry_type& geometry_object, bool is_hole, polygon_90_concept tag) {
+ void insert_dispatch(const geometry_type& geometry_object, bool is_hole, polygon_90_concept ) {
insert_vertex_sequence(begin_points(geometry_object), end_points(geometry_object), winding(geometry_object), is_hole);
}
template <typename geometry_type>
- void insert_dispatch(const geometry_type& geometry_object, bool is_hole, polygon_90_with_holes_concept tag) {
+ void insert_dispatch(const geometry_type& geometry_object, bool is_hole, polygon_90_with_holes_concept ) {
insert_vertex_sequence(begin_points(geometry_object), end_points(geometry_object), winding(geometry_object), is_hole);
for(typename polygon_with_holes_traits<geometry_type>::iterator_holes_type itr =
begin_holes(geometry_object); itr != end_holes(geometry_object);
@@ -388,11 +392,11 @@
}
}
template <typename geometry_type>
- void insert_dispatch(const geometry_type& geometry_object, bool is_hole, polygon_45_concept tag) {
+ void insert_dispatch(const geometry_type& geometry_object, bool is_hole, polygon_45_concept ) {
insert_vertex_sequence(begin_points(geometry_object), end_points(geometry_object), winding(geometry_object), is_hole);
}
template <typename geometry_type>
- void insert_dispatch(const geometry_type& geometry_object, bool is_hole, polygon_45_with_holes_concept tag) {
+ void insert_dispatch(const geometry_type& geometry_object, bool is_hole, polygon_45_with_holes_concept ) {
insert_vertex_sequence(begin_points(geometry_object), end_points(geometry_object), winding(geometry_object), is_hole);
for(typename polygon_with_holes_traits<geometry_type>::iterator_holes_type itr =
begin_holes(geometry_object); itr != end_holes(geometry_object);
@@ -401,13 +405,13 @@
}
}
template <typename geometry_type>
- void insert_dispatch(const geometry_type& geometry_object, bool is_hole, polygon_45_set_concept tag) {
+ void insert_dispatch(const geometry_type& geometry_object, bool is_hole, polygon_45_set_concept ) {
polygon_45_set_data ps;
assign(ps, geometry_object);
insert(ps, is_hole);
}
template <typename geometry_type>
- void insert_dispatch(const geometry_type& geometry_object, bool is_hole, polygon_90_set_concept tag) {
+ void insert_dispatch(const geometry_type& geometry_object, bool is_hole, polygon_90_set_concept ) {
std::list<polygon_90_data<coordinate_type> > pl;
assign(pl, geometry_object);
insert(pl.begin(), pl.end(), is_hole);
@@ -443,14 +447,14 @@
typedef polygon_45_set_concept type;
};
- template <typename iT>
- void scale_up_vertex_45_compact_range(iT beginr, iT endr, unsigned int factor) {
+ template <typename iT, typename T>
+ void scale_up_vertex_45_compact_range(iT beginr, iT endr, T factor) {
for( ; beginr != endr; ++beginr) {
scale_up((*beginr).pt, factor);
}
}
- template <typename iT>
- void scale_down_vertex_45_compact_range_blindly(iT beginr, iT endr, unsigned int factor) {
+ template <typename iT, typename T>
+ void scale_down_vertex_45_compact_range_blindly(iT beginr, iT endr, T factor) {
for( ; beginr != endr; ++beginr) {
scale_down((*beginr).pt, factor);
}
@@ -578,7 +582,8 @@
itr != polygon_set.end(); ++itr) {
const typename polygon_45_set_data<coord_type>::Vertex45Compact& v = *itr;
typename polygon_45_set_data<Unit>::Vertex45Compact v2;
- assign(v2.pt, v.pt);
+ v2.pt.x(static_cast<Unit>(v.pt.x()));
+ v2.pt.y(static_cast<Unit>(v.pt.y()));
v2.count = typename polygon_45_formation<Unit>::Vertex45Count(v.count[0], v.count[1], v.count[2], v.count[3]);
data_.push_back(v2);
}
@@ -588,7 +593,8 @@
itr != tmp.end(); ++itr) {
const typename polygon_45_set_data<coord_type>::Vertex45Compact& v = *itr;
typename polygon_45_set_data<Unit>::Vertex45Compact v2;
- assign(v2.pt, v.pt);
+ v2.pt.x(static_cast<Unit>(v.pt.x()));
+ v2.pt.y(static_cast<Unit>(v.pt.y()));
v2.count = typename polygon_45_formation<Unit>::Vertex45Count(v.count[0], v.count[1], v.count[2], v.count[3]);
error_data_.push_back(v2);
}
@@ -618,7 +624,7 @@
template <typename Unit>
template <typename geometry_type>
inline void polygon_45_set_data<Unit>::insert_dispatch(const geometry_type& geometry_object,
- bool is_hole, rectangle_concept tag) {
+ bool is_hole, rectangle_concept ) {
dirty_ = true;
unsorted_ = true;
insert_rectangle_into_vector_45(data_, geometry_object, is_hole);
@@ -1084,7 +1090,7 @@
coordinate_type resizing,
RoundingOption rounding,
CornerOption corner,
- bool hole, polygon_45_concept tag) {
+ bool hole, polygon_45_concept ) {
direction_1d wdir = winding(poly);
int multiplier = wdir == LOW ? -1 : 1;
if(hole) resizing *= -1;
@@ -1138,7 +1144,7 @@
coordinate_type resizing,
RoundingOption rounding,
CornerOption corner,
- bool hole, polygon_45_with_holes_concept tag) {
+ bool hole, polygon_45_with_holes_concept ) {
insert_with_resize_dispatch(poly, resizing, rounding, corner, hole, polygon_45_concept());
for(typename polygon_with_holes_traits<geometry_type>::iterator_holes_type itr =
begin_holes(poly); itr != end_holes(poly);
@@ -1488,7 +1494,7 @@
continue;
}
}
- if(abs(x(pt2)) % 2) { //y % 2 should also be odd
+ if(local_abs(x(pt2)) % 2) { //y % 2 should also be odd
//is corner concave or convex?
Point pts[] = {pt1, pt2, pt3};
double ar = point_sequence_area<Point*, double>(pts, pts+3);
@@ -1538,6 +1544,9 @@
}
l90sd.sort();
r90sd.sort();
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (disable: 4127)
+#endif
if(op == 0) {
output.applyBooleanBinaryOp(l90sd.begin(), l90sd.end(),
r90sd.begin(), r90sd.end(), boolean_op::BinaryCount<boolean_op::BinaryOr>());
@@ -1551,6 +1560,9 @@
output.applyBooleanBinaryOp(l90sd.begin(), l90sd.end(),
r90sd.begin(), r90sd.end(), boolean_op::BinaryCount<boolean_op::BinaryXor>());
}
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (default: 4127)
+#endif
result.data_.clear();
result.insert(output);
result.is_manhattan_ = true;
@@ -1615,7 +1627,8 @@
for(std::size_t i = 0 ; i < error_data_out.size(); ++i) {
const Vertex45Compact2& vi = error_data_out[i];
Vertex45Compact ci;
- ci.pt = (point_data<Unit2>(x(vi.pt), y(vi.pt)));
+ ci.pt.x(static_cast<Unit>(x(vi.pt)));
+ ci.pt.y(static_cast<Unit>(y(vi.pt)));
ci.count = typename polygon_45_formation<Unit>::Vertex45Count
( vi.count[0], vi.count[1], vi.count[2], vi.count[3]);
result.error_data_.push_back(ci);
@@ -1630,7 +1643,8 @@
for(std::size_t i = 0 ; i < result_data.size(); ++i) {
const Vertex45Compact2& vi = result_data[i];
Vertex45Compact ci;
- ci.pt = (point_data<Unit2>(x(vi.pt), y(vi.pt)));
+ ci.pt.x(static_cast<Unit>(x(vi.pt)));
+ ci.pt.y(static_cast<Unit>(y(vi.pt)));
ci.count = typename polygon_45_formation<Unit>::Vertex45Count
( vi.count[0], vi.count[1], vi.count[2], vi.count[3]);
result.data_.push_back(ci);
@@ -1657,6 +1671,9 @@
l90sd.insert(std::make_pair((*itr).pt.x(), std::make_pair((*itr).pt.y(), (*itr).count[3])), false, VERTICAL);
}
l90sd.sort();
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (disable: 4127)
+#endif
if(op == 0) {
l90sd.clean();
} else if (op == 1) {
@@ -1664,6 +1681,9 @@
} else if (op == 3) {
l90sd.self_xor();
}
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (default: 4127)
+#endif
result.data_.clear();
result.insert(l90sd);
result.is_manhattan_ = true;
@@ -1685,7 +1705,8 @@
for(std::size_t i = 0 ; i < data_.size(); ++i) {
const Vertex45Compact& vi = data_[i];
Vertex45Compact2 ci;
- ci.pt = point_data<Unit2>(x(vi.pt), y(vi.pt));
+ ci.pt.x(static_cast<Unit>(x(vi.pt)));
+ ci.pt.y(static_cast<Unit>(y(vi.pt)));
ci.count = typename polygon_45_formation<Unit2>::Vertex45Count
( vi.count[0], vi.count[1], vi.count[2], vi.count[3]);
lvalue_data.push_back(ci);
@@ -1716,7 +1737,8 @@
for(std::size_t i = 0 ; i < error_data_out.size(); ++i) {
const Vertex45Compact2& vi = error_data_out[i];
Vertex45Compact ci;
- ci.pt = (point_data<Unit2>(x(vi.pt), y(vi.pt)));
+ ci.pt.x(static_cast<Unit>(x(vi.pt)));
+ ci.pt.y(static_cast<Unit>(y(vi.pt)));
ci.count = typename polygon_45_formation<Unit>::Vertex45Count
( vi.count[0], vi.count[1], vi.count[2], vi.count[3]);
result.error_data_.push_back(ci);
@@ -1731,7 +1753,8 @@
for(std::size_t i = 0 ; i < result_data.size(); ++i) {
const Vertex45Compact2& vi = result_data[i];
Vertex45Compact ci;
- ci.pt = (point_data<Unit2>(x(vi.pt), y(vi.pt)));
+ ci.pt.x(static_cast<Unit>(x(vi.pt)));
+ ci.pt.y(static_cast<Unit>(y(vi.pt)));
ci.count = typename polygon_45_formation<Unit>::Vertex45Count
( vi.count[0], vi.count[1], vi.count[2], vi.count[3]);
result.data_.push_back(ci);
Modified: sandbox/gtl/boost/polygon/polygon_45_set_traits.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/polygon_45_set_traits.hpp (original)
+++ sandbox/gtl/boost/polygon/polygon_45_set_traits.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -24,9 +24,9 @@
return get_iterator_type<T>::end(polygon_set);
}
- static inline bool clean(const T& polygon_set) { return false; }
+ static inline bool clean(const T& ) { return false; }
- static inline bool sorted(const T& polygon_set) { return false; }
+ static inline bool sorted(const T& ) { return false; }
};
template <typename T>
Modified: sandbox/gtl/boost/polygon/polygon_90_set_data.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/polygon_90_set_data.hpp (original)
+++ sandbox/gtl/boost/polygon/polygon_90_set_data.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -132,7 +132,7 @@
}
template <typename geometry_type>
- inline void insert(const geometry_type& geometry_object, bool is_hole = false, orientation_2d orient = HORIZONTAL) {
+ inline void insert(const geometry_type& geometry_object, bool is_hole = false, orientation_2d = HORIZONTAL) {
iterator_geometry_to_set<typename geometry_concept<geometry_type>::type, geometry_type>
begin_input(geometry_object, LOW, orient_, is_hole), end_input(geometry_object, HIGH, orient_, is_hole);
insert(begin_input, end_input, orient_);
@@ -506,7 +506,7 @@
private:
//functions
template <typename output_container>
- void get_dispatch(output_container& output, rectangle_concept tag) const {
+ void get_dispatch(output_container& output, rectangle_concept ) const {
clean();
form_rectangles(output, data_.begin(), data_.end(), orient_, rectangle_concept());
}
Modified: sandbox/gtl/boost/polygon/polygon_90_set_traits.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/polygon_90_set_traits.hpp (original)
+++ sandbox/gtl/boost/polygon/polygon_90_set_traits.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -147,11 +147,11 @@
return indirection_type::end(polygon_set);
}
- static inline orientation_2d orient(const T& polygon_set) { return HORIZONTAL; }
+ static inline orientation_2d orient(const T&) { return HORIZONTAL; }
- static inline bool clean(const T& polygon_set) { return false; }
+ static inline bool clean(const T&) { return false; }
- static inline bool sorted(const T& polygon_set) { return false; }
+ static inline bool sorted(const T&) { return false; }
};
template <typename T>
@@ -251,7 +251,7 @@
//get dispatch functions
template <typename output_container_type, typename pst>
void get_90_dispatch(output_container_type& output, const pst& ps,
- orientation_2d orient, rectangle_concept tag) {
+ orientation_2d orient, rectangle_concept ) {
form_rectangles(output, ps.begin(), ps.end(), orient, rectangle_concept());
}
Modified: sandbox/gtl/boost/polygon/polygon_set_data.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/polygon_set_data.hpp (original)
+++ sandbox/gtl/boost/polygon/polygon_set_data.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -98,7 +98,7 @@
}
template <typename polygon_type>
- inline void insert(const polygon_type& polygon_object, bool is_hole, polygon_concept tag) {
+ inline void insert(const polygon_type& polygon_object, bool is_hole, polygon_concept ) {
bool first_iteration = true;
point_type first_point;
point_type previous_point;
@@ -148,16 +148,16 @@
}
template <typename polygon_type>
- inline void insert(const polygon_type& polygon_object, bool is_hole, polygon_45_concept tag) {
+ inline void insert(const polygon_type& polygon_object, bool is_hole, polygon_45_concept ) {
insert(polygon_object, is_hole, polygon_concept()); }
template <typename polygon_type>
- inline void insert(const polygon_type& polygon_object, bool is_hole, polygon_90_concept tag) {
+ inline void insert(const polygon_type& polygon_object, bool is_hole, polygon_90_concept ) {
insert(polygon_object, is_hole, polygon_concept()); }
template <typename polygon_with_holes_type>
inline void insert(const polygon_with_holes_type& polygon_with_holes_object, bool is_hole,
- polygon_with_holes_concept tag) {
+ polygon_with_holes_concept ) {
insert(polygon_with_holes_object, is_hole, polygon_concept());
for(typename polygon_with_holes_traits<polygon_with_holes_type>::iterator_holes_type itr =
begin_holes(polygon_with_holes_object);
@@ -168,16 +168,16 @@
template <typename polygon_with_holes_type>
inline void insert(const polygon_with_holes_type& polygon_with_holes_object, bool is_hole,
- polygon_45_with_holes_concept tag) {
+ polygon_45_with_holes_concept ) {
insert(polygon_with_holes_object, is_hole, polygon_with_holes_concept()); }
template <typename polygon_with_holes_type>
inline void insert(const polygon_with_holes_type& polygon_with_holes_object, bool is_hole,
- polygon_90_with_holes_concept tag) {
+ polygon_90_with_holes_concept ) {
insert(polygon_with_holes_object, is_hole, polygon_with_holes_concept()); }
template <typename rectangle_type>
- inline void insert(const rectangle_type& rectangle_object, bool is_hole, rectangle_concept tag) {
+ inline void insert(const rectangle_type& rectangle_object, bool is_hole, rectangle_concept ) {
polygon_90_data<coordinate_type> poly;
assign(poly, rectangle_object);
insert(poly, is_hole, polygon_concept());
@@ -441,7 +441,7 @@
get_fracture(output, false, tag);
}
template <typename output_container, typename concept_type>
- void get_fracture(output_container& container, bool fracture_holes, concept_type tag) const {
+ void get_fracture(output_container& container, bool fracture_holes, concept_type ) const {
clean();
polygon_arbitrary_formation<coordinate_type> pf(fracture_holes);
typedef typename polygon_arbitrary_formation<coordinate_type>::vertex_half_edge vertex_half_edge;
Modified: sandbox/gtl/boost/polygon/polygon_set_traits.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/polygon_set_traits.hpp (original)
+++ sandbox/gtl/boost/polygon/polygon_set_traits.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -26,9 +26,9 @@
return get_iterator_type<T>::end(polygon_set);
}
- static inline bool clean(const T& polygon_set) { return false; }
+ static inline bool clean(const T& ) { return false; }
- static inline bool sorted(const T& polygon_set) { return false; }
+ static inline bool sorted(const T& ) { return false; }
};
template <typename T>
Modified: sandbox/gtl/boost/polygon/polygon_traits.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/polygon_traits.hpp (original)
+++ sandbox/gtl/boost/polygon/polygon_traits.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -30,7 +30,7 @@
}
// Get the winding direction of the polygon
- static inline winding_direction winding(const T& t) {
+ static inline winding_direction winding(const T&) {
return unknown_winding;
}
};
@@ -66,7 +66,7 @@
}
// Get the winding direction of the polygon
- static inline winding_direction winding(const T& t) {
+ static inline winding_direction winding(const T&) {
return unknown_winding;
}
};
@@ -698,7 +698,7 @@
}
template <typename Unit>
- Unit abs(Unit value) { return value < 0 ? -value : value; }
+ Unit local_abs(Unit value) { return value < 0 ? -value : value; }
template <typename Unit>
void snap_point_vector_to_45(std::vector<point_data<Unit> >& pts) {
@@ -719,22 +719,22 @@
Unit deltax = x(pt2) - x(pt1);
Unit deltay = y(pt2) - y(pt1);
if(deltax && deltay &&
- abs(deltax) != abs(deltay)) {
+ local_abs(deltax) != local_abs(deltay)) {
//adjust the middle point
Unit ndx = x(pt3) - x(pt2);
Unit ndy = y(pt3) - y(pt2);
if(ndx && ndy) {
- Unit diff = abs(abs(deltax) - abs(deltay));
+ Unit diff = local_abs(local_abs(deltax) - local_abs(deltay));
Unit halfdiff = diff/2;
if((deltax > 0 && deltay > 0) ||
(deltax < 0 && deltay < 0)) {
//previous edge is rising slope
- if(abs(deltax + halfdiff + (diff % 2)) ==
- abs(deltay - halfdiff)) {
+ if(local_abs(deltax + halfdiff + (diff % 2)) ==
+ local_abs(deltay - halfdiff)) {
x(pt2, x(pt2) + halfdiff + (diff % 2));
y(pt2, y(pt2) - halfdiff);
- } else if(abs(deltax - halfdiff - (diff % 2)) ==
- abs(deltay + halfdiff)) {
+ } else if(local_abs(deltax - halfdiff - (diff % 2)) ==
+ local_abs(deltay + halfdiff)) {
x(pt2, x(pt2) - halfdiff - (diff % 2));
y(pt2, y(pt2) + halfdiff);
} else{
@@ -742,12 +742,12 @@
}
} else {
//previous edge is falling slope
- if(abs(deltax + halfdiff + (diff % 2)) ==
- abs(deltay + halfdiff)) {
+ if(local_abs(deltax + halfdiff + (diff % 2)) ==
+ local_abs(deltay + halfdiff)) {
x(pt2, x(pt2) + halfdiff + (diff % 2));
y(pt2, y(pt2) + halfdiff);
- } else if(abs(deltax - halfdiff - (diff % 2)) ==
- abs(deltay - halfdiff)) {
+ } else if(local_abs(deltax - halfdiff - (diff % 2)) ==
+ local_abs(deltay - halfdiff)) {
x(pt2, x(pt2) - halfdiff - (diff % 2));
y(pt2, y(pt2) - halfdiff);
} else {
@@ -764,13 +764,13 @@
} else if(ndx) {
//next edge is horizontal
//find the x value for pt1 that would make the abs(deltax) == abs(deltay)
- Unit newDeltaX = abs(deltay);
+ Unit newDeltaX = local_abs(deltay);
if(deltax < 0) newDeltaX *= -1;
x(pt2, x(pt1) + newDeltaX);
} else { //ndy
//next edge is vertical
//find the y value for pt1 that would make the abs(deltax) == abs(deltay)
- Unit newDeltaY = abs(deltax);
+ Unit newDeltaY = local_abs(deltax);
if(deltay < 0) newDeltaY *= -1;
y(pt2, y(pt1) + newDeltaY);
}
@@ -992,7 +992,7 @@
Unit deltax = x(pt) - x(prevPt);
Unit deltay = y(pt) - y(prevPt);
if(deltax && deltay &&
- abs(deltax) != abs(deltay))
+ local_abs(deltax) != local_abs(deltay))
return false;
prevPt = pt;
++itr;
@@ -1000,7 +1000,7 @@
Unit deltax = x(firstPt) - x(prevPt);
Unit deltay = y(firstPt) - y(prevPt);
if(deltax && deltay &&
- abs(deltax) != abs(deltay))
+ local_abs(deltax) != local_abs(deltay))
return false;
return true;
}
@@ -1119,7 +1119,7 @@
//odd count implies boundary condition
if(counts[0] % 2 || counts[1] % 2) return consider_touch;
//an odd number of edges to the left implies interior pt
- return counts[0] % 4;
+ return counts[0] % 4 != 0;
}
//TODO: refactor to expose as user APIs
@@ -1279,7 +1279,7 @@
}
he.first = he.second;
}
- return above % 2; //if the point is above an odd number of edges is must be inside polygon
+ return above % 2 != 0; //if the point is above an odd number of edges is must be inside polygon
}
template <typename T1, typename T2>
Modified: sandbox/gtl/boost/polygon/transform.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/transform.hpp (original)
+++ sandbox/gtl/boost/polygon/transform.hpp 2009-09-21 19:23:29 EDT (Mon, 21 Sep 2009)
@@ -253,9 +253,9 @@
// in the caller code for easier isotropic access by orientation value
inline void get_directions(direction_2d& horizontal_dir,
direction_2d& vertical_dir) const {
- bool bit2 = atr_ & 4;
- bool bit1 = atr_ & 2;
- bool bit0 = atr_ & 1;
+ bool bit2 = (atr_ & 4) != 0;
+ bool bit1 = (atr_ & 2) != 0;
+ bool bit0 = (atr_ & 1) != 0;
vertical_dir = direction_2d((direction_2d_enum)(((int)(!bit2) << 1) + !bit1));
horizontal_dir = direction_2d((direction_2d_enum)(((int)(bit2) << 1) + !bit0));
}
@@ -265,12 +265,12 @@
inline void get_directions(direction_3d& horizontal_dir,
direction_3d& vertical_dir,
direction_3d& proximal_dir) const {
- bool bit5 = atr_ & 32;
- bool bit4 = atr_ & 16;
- bool bit3 = atr_ & 8;
- bool bit2 = atr_ & 4;
- bool bit1 = atr_ & 2;
- bool bit0 = atr_ & 1;
+ bool bit5 = (atr_ & 32) != 0;
+ bool bit4 = (atr_ & 16) != 0;
+ bool bit3 = (atr_ & 8) != 0;
+ bool bit2 = (atr_ & 4) != 0;
+ bool bit1 = (atr_ & 2) != 0;
+ bool bit0 = (atr_ & 1) != 0;
proximal_dir = direction_3d((direction_2d_enum)((((int)(!bit4 & !bit5)) << 2) +
((int)(bit5) << 1) +
!bit3));
@@ -339,17 +339,29 @@
template <typename scale_factor_type>
class anisotropic_scale_factor {
public:
- inline anisotropic_scale_factor() : scale_() {
+ inline anisotropic_scale_factor()
+#ifndef BOOST_POLYGON_MSVC
+ : scale_()
+#endif
+ {
scale_[0] = 1;
scale_[1] = 1;
scale_[2] = 1;
}
- inline anisotropic_scale_factor(scale_factor_type xscale, scale_factor_type yscale) : scale_() {
+ inline anisotropic_scale_factor(scale_factor_type xscale, scale_factor_type yscale)
+#ifndef BOOST_POLYGON_MSVC
+ : scale_()
+#endif
+ {
scale_[0] = xscale;
scale_[1] = yscale;
scale_[2] = 1;
}
- inline anisotropic_scale_factor(scale_factor_type xscale, scale_factor_type yscale, scale_factor_type zscale) : scale_() {
+ inline anisotropic_scale_factor(scale_factor_type xscale, scale_factor_type yscale, scale_factor_type zscale)
+#ifndef BOOST_POLYGON_MSVC
+ : scale_()
+#endif
+ {
scale_[0] = xscale;
scale_[1] = yscale;
scale_[2] = zscale;
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk