Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r80595 - trunk/boost/polygon/detail
From: lucanus.j.simonson_at_[hidden]
Date: 2012-09-18 20:26:16

Next message: lucanus.j.simonson_at_[hidden]: "[Boost-commit] svn:boost r80596 - trunk/boost/polygon/detail"
Previous message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r80594 - in trunk/boost/thread: . detail"

Author: ljsimons
Date: 2012-09-18 20:26:14 EDT (Tue, 18 Sep 2012)
New Revision: 80595
URL: http://svn.boost.org/trac/boost/changeset/80595

Log:
fixed std::cout for clang
Text files modified:
   trunk/boost/polygon/detail/boolean_op_45.hpp | 110 ++++++++--------
   trunk/boost/polygon/detail/polygon_45_formation.hpp | 178 +++++++++++++-------------
   trunk/boost/polygon/detail/polygon_arbitrary_formation.hpp | 258 ++++++++++++++++++++--------------------
   trunk/boost/polygon/detail/scan_arbitrary.hpp | 170 +++++++++++++-------------
   4 files changed, 358 insertions(+), 358 deletions(-)

Modified: trunk/boost/polygon/detail/boolean_op_45.hpp
==============================================================================
--- trunk/boost/polygon/detail/boolean_op_45.hpp (original)
+++ trunk/boost/polygon/detail/boolean_op_45.hpp 2012-09-18 20:26:14 EDT (Tue, 18 Sep 2012)
@@ -395,9 +395,9 @@
 int edgeType = applyLogic<op>(count1, count2);
 if(edgeType) {
 int multiplier = end == LOW ? -1 : 1;
- //std::cout << "cross logic: " << edgeType << std::endl;
+ //std::cout << "cross logic: " << edgeType << "\n";
 output.insert(output.end(), Vertex45(pt, rise, edgeType * multiplier));
- //std::cout << "write out: " << crossPoint << " " << Point(eraseItrs[i]->x, eraseItrs[i]->y) << std::endl;
+ //std::cout << "write out: " << crossPoint << " " << Point(eraseItrs[i]->x, eraseItrs[i]->y) << "\n";
 }
 }
 };
@@ -428,9 +428,9 @@
 int edgeType = applyLogic<op>(count1, count2);
 if(edgeType) {
 int multiplier = end == LOW ? -1 : 1;
- //std::cout << "cross logic: " << edgeType << std::endl;
+ //std::cout << "cross logic: " << edgeType << "\n";
 output.insert(output.end(), Vertex45(pt, rise, edgeType * multiplier));
- //std::cout << "write out: " << crossPoint << " " << Point(eraseItrs[i]->x, eraseItrs[i]->y) << std::endl;
+ //std::cout << "write out: " << crossPoint << " " << Point(eraseItrs[i]->x, eraseItrs[i]->y) << "\n";
 }
 }
 };
@@ -510,18 +510,18 @@
 //std::cout << "1\n";
 while(inputBegin != inputEnd) {
 //std::cout << "2\n";
- //std::cout << "x_ = " << x_ << std::endl;
- //std::cout << "scan line size: " << scanData_.size() << std::endl;
+ //std::cout << "x_ = " << x_ << "\n";
+ //std::cout << "scan line size: " << scanData_.size() << "\n";
 //for(iterator iter = scanData_.begin();
 // iter != scanData_.end(); ++iter) {
 // std::cout << "scan element\n";
- // std::cout << *iter << " " << iter->evalAtX(x_) << std::endl;
+ // std::cout << *iter << " " << iter->evalAtX(x_) << "\n";
 // }
- // std::cout << "cross queue size: " << crossQueue_.size() << std::endl;
- // std::cout << "cross vector size: " << crossVector_.size() << std::endl;
+ // std::cout << "cross queue size: " << crossQueue_.size() << "\n";
+ // std::cout << "cross vector size: " << crossVector_.size() << "\n";
 //for(CrossQueue::iterator cqitr = crossQueue_.begin(); cqitr != crossQueue_.end(); ++cqitr) {
 // std::cout << *cqitr << " ";
- //} std::cout << std::endl;
+ //} std::cout << "\n";
 Unit nextX = (*inputBegin).first.x();
 if(!crossVector_.empty() && crossVector_[0].first.x() < nextX) nextX = crossVector_[0].first.x();
 if(nextX != x_) {
@@ -567,18 +567,18 @@
 //std::cout << "loop\n";
 //pop point off the cross queue
 Point crossPoint = *(crossQueue_.begin());
- //std::cout << crossPoint << std::endl;
+ //std::cout << crossPoint << "\n";
 //for(iterator iter = scanData_.begin();
 // iter != scanData_.end(); ++iter) {
 // std::cout << "scan element\n";
- // std::cout << *iter << " " << iter->evalAtX(x_) << std::endl;
+ // std::cout << *iter << " " << iter->evalAtX(x_) << "\n";
 //}
 crossQueue_.erase(crossQueue_.begin());
 Scan45Vertex vertex(crossPoint, Scan45Count());
 iterator lowIter = lookUp_(vertex.first.y());
- //std::cout << "searching at: " << vertex.first.y() << std::endl;
+ //std::cout << "searching at: " << vertex.first.y() << "\n";
 //if(lowIter == scanData_.end()) std::cout << "could not find\n";
- //else std::cout << "found: " << *lowIter << std::endl;
+ //else std::cout << "found: " << *lowIter << "\n";
 if(lowIter == scanData_.end() ||
 lowIter->evalAtX(x_) != vertex.first.y()) {
 // std::cout << "skipping\n";
@@ -593,7 +593,7 @@
 --searchDownItr;
 countBelow = searchDownItr->count;
 }
- //std::cout << "Below Count: " << countBelow << std::endl;
+ //std::cout << "Below Count: " << countBelow << "\n";
 Scan45Count count(countBelow);
 std::size_t numEdges = 0;
 iterator eraseItrs[3];
@@ -601,7 +601,7 @@
 lowIter->evalAtX(x_) == vertex.first.y()) {
 for(int index = lowIter->rise +1; index >= 0; --index)
 count[index] = lowIter->count;
- //std::cout << count << std::endl;
+ //std::cout << count << "\n";
 eraseItrs[numEdges] = lowIter;
 ++numEdges;
 ++lowIter;
@@ -630,8 +630,8 @@
 vertex.second[0] = count[0] - count[1];
 //add the point, deriviative pair into the cross vector
 //std::cout << "LOOK HERE!\n";
- //std::cout << count << std::endl;
- //std::cout << vertex << std::endl;
+ //std::cout << count << "\n";
+ //std::cout << vertex << "\n";
 crossVector_.push_back(vertex);
 }
 //erase crossing elements
@@ -686,10 +686,10 @@
 iterator prevIter = scanData_.end();
 while(inputBegin != inputEnd &&
 (*inputBegin).first.x() == x_) {
- //std::cout << (*inputBegin) << std::endl;
+ //std::cout << (*inputBegin) << "\n";
 //std::cout << "loop\n";
 Scan45Vertex vertex = *inputBegin;
- //std::cout << vertex.first << std::endl;
+ //std::cout << vertex.first << "\n";
 //if vertical count propigating up fake a null event at the next element
 if(verticalCount != CountType() && (prevIter != scanData_.end() &&
 prevIter->evalAtX(x_) < vertex.first.y())) {
@@ -707,13 +707,13 @@
 ++inputBegin;
 }
 }
- //std::cout << vertex.second << std::endl;
+ //std::cout << vertex.second << "\n";
 //integrate vertex
 CountType currentCount = verticalCount;// + vertex.second[0];
 for(unsigned int i = 0; i < 3; ++i) {
 vertex.second[i] = currentCount += vertex.second[i];
 }
- //std::cout << vertex.second << std::endl;
+ //std::cout << vertex.second << "\n";
 //vertex represents the change in state at this point

 //get counts at current vertex
@@ -725,8 +725,8 @@
 countBelow = lowIter->count;
 ++lowIter;
 }
- //std::cout << "Count Below: " << countBelow[0] << " " << countBelow[1] << std::endl;
- //std::cout << "vertical count: " << verticalCount[0] << " " << verticalCount[1] << std::endl;
+ //std::cout << "Count Below: " << countBelow[0] << " " << countBelow[1] << "\n";
+ //std::cout << "vertical count: " << verticalCount[0] << " " << verticalCount[1] << "\n";
 Scan45Count countAt(countBelow - verticalCount);
 //check if the vertical edge should be written out
 if(verticalCount != CountType()) {
@@ -756,20 +756,20 @@
 }
 verticalCount += vertex.second[3];
 prevPoint = vertex.first;
- //std::cout << "new vertical count: " << verticalCount[0] << " " << verticalCount[1] << std::endl;
+ //std::cout << "new vertical count: " << verticalCount[0] << " " << verticalCount[1] << "\n";
 prevIter = lowIter;
 //count represents the current state at this point
- //std::cout << vertex.second << std::endl;
- //std::cout << countAt << std::endl;
+ //std::cout << vertex.second << "\n";
+ //std::cout << countAt << "\n";
 //std::cout << "ADD\n";
 vertex.second += countAt;
- //std::cout << vertex.second << std::endl;
+ //std::cout << vertex.second << "\n";

 //add elements to the scanline
 for(int i = 0; i < 3; ++i) {
 if(vertex.second[i] != countBelow) {
 //std::cout << "insert: " << vertex.first.x() << " " << vertex.first.y() << " " << i-1 <<
- // " " << vertex.second[i][0] << " " << vertex.second[i][1] << std::endl;
+ // " " << vertex.second[i][0] << " " << vertex.second[i][1] << "\n";
 iterator insertIter = scanData_.insert(scanData_.end(),
 Scan45ElementT<CountType>(vertex.first.x(),
 vertex.first.y(),
@@ -864,7 +864,7 @@
 }
 }
 }
- //std::cout << std::endl;
+ //std::cout << "\n";
 }

 inline iterator lookUp_(Unit y){
@@ -878,7 +878,7 @@
 // lessScan45Element<CountType> >& data) {
 // typename std::set<Scan45ElementT<CountType>, lessScan45Element<CountType> >::const_iterator iter;
 // for(iter = data.begin(); iter != data.end(); ++iter) {
- // std::cout << iter->x << " " << iter->y << " " << iter->rise << std::endl;
+ // std::cout << iter->x << " " << iter->y << " " << iter->rise << "\n";
 // }
 //}

@@ -957,13 +957,13 @@
 reference.push_back(Vertex45(Point(10, 10), 2, 1));
 reference.push_back(Vertex45(Point(10, 10), 0, 1));
 if(result != reference) {
- stdcout << "result size == " << result.size() << std::endl;
+ stdcout << "result size == " << result.size() << "\n";
 for(std::size_t i = 0; i < result.size(); ++i) {
- //std::cout << "result == " << result[i]<< std::endl;
+ //std::cout << "result == " << result[i]<< "\n";
 }
- stdcout << "reference size == " << reference.size() << std::endl;
+ stdcout << "reference size == " << reference.size() << "\n";
 for(std::size_t i = 0; i < reference.size(); ++i) {
- //std::cout << "reference == " << reference[i]<< std::endl;
+ //std::cout << "reference == " << reference[i]<< "\n";
 }
 return false;
 }
@@ -1007,13 +1007,13 @@
 reference.push_back(Vertex45(Point(10, 20), 2, 1));
 reference.push_back(Vertex45(Point(10, 20), 1, 1));
 if(result != reference) {
- stdcout << "result size == " << result.size() << std::endl;
+ stdcout << "result size == " << result.size() << "\n";
 for(std::size_t i = 0; i < result.size(); ++i) {
- //std::cout << "result == " << result[i]<< std::endl;
+ //std::cout << "result == " << result[i]<< "\n";
 }
- stdcout << "reference size == " << reference.size() << std::endl;
+ stdcout << "reference size == " << reference.size() << "\n";
 for(std::size_t i = 0; i < reference.size(); ++i) {
- //std::cout << "reference == " << reference[i]<< std::endl;
+ //std::cout << "reference == " << reference[i]<< "\n";
 }
 return false;
 }
@@ -1057,13 +1057,13 @@
 reference.push_back(Vertex45(Point(20, 10), 1, -1));
 reference.push_back(Vertex45(Point(20, 10), 0, 1));
 if(result != reference) {
- stdcout << "result size == " << result.size() << std::endl;
+ stdcout << "result size == " << result.size() << "\n";
 for(std::size_t i = 0; i < result.size(); ++i) {
- //stdcout << "result == " << result[i]<< std::endl;
+ //stdcout << "result == " << result[i]<< "\n";
 }
- stdcout << "reference size == " << reference.size() << std::endl;
+ stdcout << "reference size == " << reference.size() << "\n";
 for(std::size_t i = 0; i < reference.size(); ++i) {
- //stdcout << "reference == " << reference[i]<< std::endl;
+ //stdcout << "reference == " << reference[i]<< "\n";
 }
 return false;
 }
@@ -1114,13 +1114,13 @@
 reference.push_back(Vertex45(Point(10, 10), 2, 1));
 reference.push_back(Vertex45(Point(10, 10), 0, 1));
 if(result != reference) {
- stdcout << "result size == " << result.size() << std::endl;
+ stdcout << "result size == " << result.size() << "\n";
 for(std::size_t i = 0; i < result.size(); ++i) {
- //stdcout << "result == " << result[i]<< std::endl;
+ //stdcout << "result == " << result[i]<< "\n";
 }
- stdcout << "reference size == " << reference.size() << std::endl;
+ stdcout << "reference size == " << reference.size() << "\n";
 for(std::size_t i = 0; i < reference.size(); ++i) {
- //stdcout << "reference == " << reference[i]<< std::endl;
+ //stdcout << "reference == " << reference[i]<< "\n";
 }
 return false;
 }
@@ -1176,8 +1176,8 @@
 // result == 12 8 1 -1
 // result == 12 8 -1 1
 if(result.size() != 24) {
- //stdcout << "result size == " << result.size() << std::endl;
- //stdcout << "reference size == " << 24 << std::endl;
+ //stdcout << "result size == " << result.size() << "\n";
+ //stdcout << "reference size == " << 24 << "\n";
 return false;
 }
 stdcout << "done testing Scan45Star1\n";
@@ -1232,8 +1232,8 @@
 // result == 16 8 1 -1
 // result == 16 8 0 1
 if(result.size() != 24) {
- //std::cout << "result size == " << result.size() << std::endl;
- //std::cout << "reference size == " << 24 << std::endl;
+ //std::cout << "result size == " << result.size() << "\n";
+ //std::cout << "reference size == " << 24 << "\n";
 return false;
 }
 stdcout << "done testing Scan45Star2\n";
@@ -1297,8 +1297,8 @@
 // result == 12 14 2 1
 // result == 12 14 0 1
 if(result.size() != 28) {
- //std::cout << "result size == " << result.size() << std::endl;
- //std::cout << "reference size == " << 28 << std::endl;
+ //std::cout << "result size == " << result.size() << "\n";
+ //std::cout << "reference size == " << 28 << "\n";
 return false;
 }

@@ -1364,8 +1364,8 @@
 // result == 16 12 2 1
 // result == 16 12 0 1
 if(result.size() != 28) {
- //stdcout << "result size == " << result.size() << std::endl;
- //stdcout << "reference size == " << 28 << std::endl;
+ //stdcout << "result size == " << result.size() << "\n";
+ //stdcout << "reference size == " << 28 << "\n";
 return false;
 }

Modified: trunk/boost/polygon/detail/polygon_45_formation.hpp
==============================================================================
--- trunk/boost/polygon/detail/polygon_45_formation.hpp (original)
+++ trunk/boost/polygon/detail/polygon_45_formation.hpp 2012-09-18 20:26:14 EDT (Tue, 18 Sep 2012)
@@ -311,7 +311,7 @@
 at1->copyHoles(*(at1->otherTailp_));
 //std::cout << "test2\n";
 //Polygon45WithHolesImpl<PolyLine45PolygonData> poly(polyData);
- //std::cout << poly << std::endl;
+ //std::cout << poly << "\n";
 //std::cout << "test3\n";
 typedef typename cT::value_type pType;
 output.push_back(pType());
@@ -319,14 +319,14 @@
 typename PolyLineByConcept<Unit, cType>::type polyData(at1);
 assign(output.back(), polyData);
 //std::cout << "test4\n";
- //std::cout << "delete " << at1->otherTailp_ << std::endl;
+ //std::cout << "delete " << at1->otherTailp_ << "\n";
 //at1->print();
 //at1->otherTailp_->print();
 delete at1->otherTailp_;
 //at1->print();
 //at1->otherTailp_->print();
 //std::cout << "test5\n";
- //std::cout << "delete " << at1 << std::endl;
+ //std::cout << "delete " << at1 << "\n";
 delete at1;
 //std::cout << "test6\n";
 return 0;
@@ -345,7 +345,7 @@

 inline void destroyContents() {
 if(otherTailp_) {
- //std::cout << "delete p " << tailp_ << std::endl;
+ //std::cout << "delete p " << tailp_ << "\n";
 if(tailp_) delete tailp_;
 tailp_ = 0;
 otherTailp_->otherTailp_ = 0;
@@ -353,7 +353,7 @@
 otherTailp_ = 0;
 }
 for(typename std::list<ActiveTail45*>::iterator itr = holesList_.begin(); itr != holesList_.end(); ++itr) {
- //std::cout << "delete p " << (*itr) << std::endl;
+ //std::cout << "delete p " << (*itr) << "\n";
 if(*itr) {
 if((*itr)->otherTailp_) {
 delete (*itr)->otherTailp_;
@@ -367,7 +367,7 @@
 }

// inline void print() {
-// std::cout << this << " " << tailp_ << " " << otherTailp_ << " " << holesList_.size() << " " << head_ << std::endl;
+// std::cout << this << " " << tailp_ << " " << otherTailp_ << " " << holesList_.size() << " " << head_ << "\n";
// }

 static inline std::pair<ActiveTail45*, ActiveTail45*> createActiveTail45sAsPair(Point point, bool solid,
@@ -575,9 +575,9 @@
 while(inputBegin != inputEnd) {
 //std::cout << "2\n";
 x_ = (*inputBegin).pt.x();
- //std::cout << "SCAN FORMATION " << x_ << std::endl;
- //std::cout << "x_ = " << x_ << std::endl;
- //std::cout << "scan line size: " << scanData_.size() << std::endl;
+ //std::cout << "SCAN FORMATION " << x_ << "\n";
+ //std::cout << "x_ = " << x_ << "\n";
+ //std::cout << "scan line size: " << scanData_.size() << "\n";
 inputBegin = processEvent_(output, inputBegin, inputEnd);
 }
 }
@@ -587,7 +587,7 @@
 template <class cT, class cT2>
 inline std::pair<int, ActiveTail45*> processPoint_(cT& output, cT2& elements, Point point,
 Vertex45Count& counts, ActiveTail45** tails, Vertex45Count& incoming) {
- //std::cout << point << std::endl;
+ //std::cout << point << "\n";
 //std::cout << counts[0] << " ";
 //std::cout << counts[1] << " ";
 //std::cout << counts[2] << " ";
@@ -600,14 +600,14 @@
 ActiveTail45* returnValue = 0;
 int returnCount = 0;
 for(int i = 0; i < 3; ++i) {
- //std::cout << i << std::endl;
+ //std::cout << i << "\n";
 if(counts[i] == -1) {
 //std::cout << "fixed i\n";
 for(int j = i + 1; j < 4; ++j) {
- //std::cout << j << std::endl;
+ //std::cout << j << "\n";
 if(counts[j]) {
 if(counts[j] == 1) {
- //std::cout << "case1: " << i << " " << j << std::endl;
+ //std::cout << "case1: " << i << " " << j << "\n";
 //if a figure is closed it will be written out by this function to output
 ActiveTail45::joinChains(point, tails[i], tails[j], true, output);
 counts[i] = 0;
@@ -623,14 +623,14 @@
 //find any pairs of incoming edges that need to create pair for leading solid
 //std::cout << "checking case2\n";
 for(int i = 0; i < 3; ++i) {
- //std::cout << i << std::endl;
+ //std::cout << i << "\n";
 if(incoming[i] == 1) {
 //std::cout << "fixed i\n";
 for(int j = i + 1; j < 4; ++j) {
- //std::cout << j << std::endl;
+ //std::cout << j << "\n";
 if(incoming[j]) {
 if(incoming[j] == -1) {
- //std::cout << "case2: " << i << " " << j << std::endl;
+ //std::cout << "case2: " < tailPair =
 ActiveTail45::createActiveTail45sAsPair(point, true, 0, fractureHoles_ != 0);
@@ -642,10 +642,10 @@
 returnCount = 1;
 } else {
 Vertex45 vertex(point, i -1, incoming[i]);
- //std::cout << "new element " << j-1 << " " << -1 << std::endl;
+ //std::cout << "new element " << j-1 << " " << -1 << "\n";
 elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, j -1, -1), tailPair.first));
 }
- //std::cout << "new element " << i-1 << " " << 1 << std::endl;
+ //std::cout << "new element " << i-1 << " " << 1 << "\n";
 elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, i -1, 1), tailPair.second));
 incoming[i] = 0;
 incoming[j] = 0;
@@ -662,14 +662,14 @@
 //find pass through with solid on top
 //std::cout << "checking case 3\n";
 for(int i = 0; i < 4; ++i) {
- //std::cout <= 0; --j) {
 if(incoming[j] != 0) {
 if(incoming[j] == 1) {
- //std::cout << "case3: " <print();
 //pass through solid on top
 tails[i]->pushPoint(point);
@@ -699,14 +699,14 @@
 for(int j = 0; j < 4; ++j) {
 if(incoming[j] != 0) {
 if(incoming[j] == -1) {
- //std::cout << "case4: " <pushPoint(point);
 if(j == 3) {
 returnValue = tails[i];
 returnCount = 1;
 } else {
- //std::cout << "new element " << j-1 << " " << incoming[j] << std::endl;
+ //std::cout << "new element " << j-1 << " " << incoming[j] << "\n";
 elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, j -1, incoming[j]), tails[i]));
 }
 tails[i] = 0;
@@ -728,7 +728,7 @@
 if(counts[i] != 0) {
 for(int j = i+1; j < 4; ++j) {
 if(counts[j] != 0) {
- //std::cout << "case5: " << i << " " << j << std::endl;
+ //std::cout << "case5: " << i << " " << j << "\n";
 //we are ending a hole and may potentially close a figure and have to handle the hole
 returnValue = ActiveTail45::joinChains(point, tails[i], tails[j], false, output);
 tails[i] = 0;
@@ -746,7 +746,7 @@
 if(incoming[i] != 0) {
 for(int j = i+1; j < 4; ++j) {
 if(incoming[j] != 0) {
- //std::cout << "case6: " << i << " " << j << std::endl;
+ //std::cout << "case6: " << i << " " << j << "\n";
 //we are beginning a empty space
 ActiveTail45* holep = 0;
 if(counts[3] == 0) holep = tails[3];
@@ -756,10 +756,10 @@
 returnValue = tailPair.first;
 returnCount = -1;
 } else {
- //std::cout << "new element " << j-1 << " " << incoming[j] << std::endl;
+ //std::cout << "new element " << j-1 << " " << incoming[j] << "\n";
 elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, j -1, incoming[j]), tailPair.first));
 }
- //std::cout << "new element " << i-1 << " " << incoming[i] << std::endl;
+ //std::cout << "new element " << i-1 << " " << incoming[i] << "\n";
 elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, i -1, incoming[i]), tailPair.second));
 incoming[i] = 0;
 incoming[j] = 0;
@@ -798,7 +798,7 @@
 //std::cout << "loop2\n";
 elementIters.push_back(iter);
 int index = iter->first.rise + 1;
- //std::cout << index << " " << iter->first.count << std::endl;
+ //std::cout << index << " " << iter->first.count << "\n";
 counts[index] = iter->first.count;
 tails[index] = iter->second;
 ++iter;
@@ -834,7 +834,7 @@
 verticalCount = result.first;
 verticalTail = result.second;
 //if(verticalTail) std::cout << "have vertical tail\n";
- //std::cout << "verticalCount: " << verticalCount << std::endl;
+ //std::cout << "verticalCount: " << verticalCount << "\n";
 if(verticalTail && !verticalCount) {
 //we got a hole out of the point we just processed
 //iter is still at the next y element above the current y value in the tree
@@ -906,9 +906,9 @@
 data.push_back(Vertex45(Point(10, 10), 0, 1));
 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon formation\n";
 return true;
@@ -930,9 +930,9 @@
 data.push_back(Vertex45(Point(10, 20), 1, 1));
 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon formation\n";
 return true;
@@ -955,9 +955,9 @@
 data.push_back(Vertex45(Point(20, 10), 0, 1));
 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon formation\n";
 return true;
@@ -1020,9 +1020,9 @@
 data.push_back(Vertex45(Point(12, 8), -1, 1));
 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon formation\n";
 return true;
@@ -1053,9 +1053,9 @@

 polygon_sort(result.begin(), result.end());
 pf.scan(polys, result.begin(), result.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon formation\n";
 return true;
@@ -1125,9 +1125,9 @@

 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon formation\n";
 return true;
@@ -1197,9 +1197,9 @@

 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon formation\n";
 return true;
@@ -1241,9 +1241,9 @@

 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon formation\n";
 return true;
@@ -1289,9 +1289,9 @@
 while(inputBegin != inputEnd) {
 //std::cout << "2\n";
 x_ = (*inputBegin).pt.x();
- //std::cout << "SCAN FORMATION " << x_ << std::endl;
- //std::cout << "x_ = " << x_ << std::endl;
- //std::cout << "scan line size: " << scanData_.size() << std::endl;
+ //std::cout << "SCAN FORMATION " << x_ << "\n";
+ //std::cout << "x_ = " << x_ << "\n";
+ //std::cout << "scan line size: " << scanData_.size() << "\n";
 inputBegin = processEvent_(output, inputBegin, inputEnd);
 }
 }
@@ -1316,7 +1316,7 @@
 std::pair<ActiveTail45*, ActiveTail45*>& verticalPair,
 iterator previter, Point point,
 Vertex45Count& counts, ActiveTail45** tails, Vertex45Count& incoming) {
- //std::cout << point << std::endl;
+ //std::cout << point << "\n";
 //std::cout << counts[0] << " ";
 //std::cout << counts[1] << " ";
 //std::cout << counts[2] << " ";
@@ -1332,14 +1332,14 @@
 verticalPairOut.second = 0;
 int returnCount = 0;
 for(int i = 0; i < 3; ++i) {
- //std::cout << i << std::endl;
+ //std::cout << i << "\n";
 if(counts[i] == -1) {
 //std::cout << "fixed i\n";
 for(int j = i + 1; j < 4; ++j) {
- //std::cout << j << std::endl;
+ //std::cout << j << "\n";
 if(counts[j]) {
 if(counts[j] == 1) {
- //std::cout << "case1: " << i << " " << j << std::endl;
+ //std::cout << "case1: " << i << " " << j << "\n";
 //if a figure is closed it will be written out by this function to output
 ActiveTail45::joinChains(point, tails[i], tails[j], true, output);
 counts[i] = 0;
@@ -1355,14 +1355,14 @@
 //find any pairs of incoming edges that need to create pair for leading solid
 //std::cout << "checking case2\n";
 for(int i = 0; i < 3; ++i) {
- //std::cout << i << std::endl;
+ //std::cout << i << "\n";
 if(incoming[i] == 1) {
 //std::cout << "fixed i\n";
 for(int j = i + 1; j < 4; ++j) {
- //std::cout << j << std::endl;
+ //std::cout << j << "\n";
 if(incoming[j]) {
 if(incoming[j] == -1) {
- //std::cout << "case2: " << i << " " << j << std::endl;
+ //std::cout << "case2: " < tailPair =
 ActiveTail45::createActiveTail45sAsPair(point, true, 0, false);
@@ -1374,10 +1374,10 @@
 returnCount = 1;
 } else {
 Vertex45 vertex(point, i -1, incoming[i]);
- //std::cout << "new element " << j-1 << " " << -1 << std::endl;
+ //std::cout << "new element " << j-1 << " " << -1 << "\n";
 elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, j -1, -1), tailPair.first));
 }
- //std::cout << "new element " << i-1 << " " << 1 << std::endl;
+ //std::cout << "new element " << i-1 << " " << 1 << "\n";
 elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, i -1, 1), tailPair.second));
 incoming[i] = 0;
 incoming[j] = 0;
@@ -1394,14 +1394,14 @@
 //find pass through with solid on top
 //std::cout << "checking case 3\n";
 for(int i = 0; i < 4; ++i) {
- //std::cout <= 0; --j) {
 if(incoming[j] != 0) {
 if(incoming[j] == 1) {
- //std::cout << "case3: " <print();
 //pass through solid on top
 if(i != 3)
@@ -1437,10 +1437,10 @@
 for(int j = 0; j < 4; ++j) {
 if(incoming[j] != 0) {
 if(incoming[j] == -1) {
- //std::cout << "case4: " << i << " " << j << std::endl;
+ //std::cout << "case4: " << i << " " << j << "\n";
 //pass through solid on bottom
 if(i == 3) {
- //std::cout << "new element " << j-1 << " " << incoming[j] << std::endl;
+ //std::cout << "new element " << j-1 << " " << incoming[j] << "\n";
 if(j == 3) {
 returnValue = tails[i];
 returnCount = 1;
@@ -1483,7 +1483,7 @@
 if(counts[i] != 0) {
 for(int j = i+1; j < 4; ++j) {
 if(counts[j] != 0) {
- //std::cout << "case5: " << i << " " << j << std::endl;
+ //std::cout << "case5: " <pushPoint(point);
 verticalPairOut.first = tails[i];
@@ -1511,7 +1511,7 @@
 if(incoming[i] != 0) {
 for(int j = i+1; j < 4; ++j) {
 if(incoming[j] != 0) {
- //std::cout << "case6: " << i << " " << j << std::endl;
+ //std::cout << "case6: " << i << " " << j << "\n";
 //we are beginning a empty space
 if(verticalPair.first == 0) {
 getVerticalPair_(verticalPair, previter);
@@ -1523,12 +1523,12 @@
 } else {
 std::pair<ActiveTail45*, ActiveTail45*> tailPair =
 ActiveTail45::createActiveTail45sAsPair(point, true, 0, false);
- //std::cout << "new element " << j-1 << " " << incoming[j] << std::endl;
+ //std::cout << "new element " << j-1 << " " << incoming[j] << "\n";
 elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, j -1, incoming[j]), tailPair.second));
 verticalPairOut.second = tailPair.first;
 verticalPairOut.first = verticalPair.first;
 }
- //std::cout << "new element " << i-1 << " " << incoming[i] << std::endl;
+ //std::cout << "new element " << i-1 << " " << incoming[i] << "\n";
 elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, i -1, incoming[i]), verticalPair.second));
 incoming[i] = 0;
 incoming[j] = 0;
@@ -1578,7 +1578,7 @@
 //std::cout << "loop2\n";
 elementIters.push_back(iter);
 int index = iter->first.rise + 1;
- //std::cout << index << " " << iter->first.count << std::endl;
+ //std::cout << index << " " << iter->first.count << "\n";
 counts[index] = iter->first.count;
 tails[index] = iter->second;
 ++iter;
@@ -1670,9 +1670,9 @@
 data.push_back(Vertex45(Point(10, 10), 0, 1));
 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon tiling\n";
 return true;
@@ -1694,9 +1694,9 @@
 data.push_back(Vertex45(Point(10, 20), 1, 1));
 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon tiling\n";
 return true;
@@ -1718,9 +1718,9 @@
 data.push_back(Vertex45(Point(20, 10), 0, 1));
 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon tiling\n";
 return true;
@@ -1744,9 +1744,9 @@
 data.push_back(Vertex45(Point(20, 20), 2, 1));
 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon tiling\n";
 return true;
@@ -1770,9 +1770,9 @@
 data.push_back(Vertex45(Point(20, -10), 2, -1));
 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon tiling\n";
 return true;
@@ -1803,9 +1803,9 @@
 data.push_back(Vertex45(Point(3, 2), 0, -1));
 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon tiling\n";
 return true;
@@ -1837,9 +1837,9 @@

 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon tiling\n";
 return true;
@@ -1901,9 +1901,9 @@
 data.push_back(Vertex45(Point(12, 8), -1, 1));
 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon tiling\n";
 return true;
@@ -1935,9 +1935,9 @@

 polygon_sort(result.begin(), result.end());
 pf.scan(polys, result.begin(), result.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon tiling\n";
 return true;
@@ -2007,9 +2007,9 @@

 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon tiling\n";
 return true;
@@ -2079,9 +2079,9 @@

 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon tiling\n";
 return true;
@@ -2123,9 +2123,9 @@

 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon tiling\n";
 return true;

Modified: trunk/boost/polygon/detail/polygon_arbitrary_formation.hpp
==============================================================================
--- trunk/boost/polygon/detail/polygon_arbitrary_formation.hpp (original)
+++ trunk/boost/polygon/detail/polygon_arbitrary_formation.hpp 2012-09-18 20:26:14 EDT (Tue, 18 Sep 2012)
@@ -442,8 +442,8 @@
 y_den = (dx1 * dy2 - dx2 * dy1);
 x = x_num / x_den;
 y = y_num / y_den;
- //std::cout << "cross1 " << dy1 << " " << dx2 << " " << dy1 * dx2 << std::endl;
- //std::cout << "cross2 " << dy2 << " " << dx1 << " " << dy2 * dx1 << std::endl;
+ //std::cout << "cross1 " << dy1 << " " << dx2 << " " << dy1 * dx2 << "\n";
+ //std::cout << "cross2 " << dy2 << " " << dx1 << " " << dy2 * dx1 << "\n";
 //Unit exp_x = compute_x_intercept<at>(x11, x21, y11, y21, dy1, dy2, dx1, dx2);
 //Unit exp_y = compute_x_intercept<at>(y11, y21, x11, x21, dx1, dx2, dy1, dy2);
 if(round_closest) {
@@ -460,10 +460,10 @@
 if(is_horizontal(he2))
 y_unit = he2.first.y();
 //if(x != exp_x || y != exp_y)
- // std::cout << exp_x << " " << exp_y << " " << x << " " << y << std::endl;
+ // std::cout << exp_x << " " << exp_y << " " << x << " " << y << "\n";
 //Unit y1 = evalAtXforY(exp_x, he1.first, he1.second);
 //Unit y2 = evalAtXforY(exp_x, he2.first, he2.second);
- //std::cout << exp_x << " " << exp_y << " " << y1 << " " << y2 << std::endl;
+ //std::cout << exp_x << " " << exp_y << " " << y1 << " " << y2 << "\n";
 Point result(x_unit, y_unit);
 if(!projected && !contains(rect1, result, true)) return false;
 if(!projected && !contains(rect2, result, true)) return false;
@@ -554,9 +554,9 @@
 y_den = (dx1 * dy2 - dx2 * dy1);
 x = x_num / x_den;
 y = y_num / y_den;
- //std::cout << x << " " << y << std::endl;
- //std::cout << "cross1 " << dy1 << " " << dx2 << " " << dy1 * dx2 << std::endl;
- //std::cout << "cross2 " << dy2 << " " << dx1 << " " << dy2 * dx1 << std::endl;
+ //std::cout << x << " " << y << "\n";
+ //std::cout << "cross1 " << dy1 << " " << dx2 << " " << dy1 * dx2 << "\n";
+ //std::cout << "cross2 " << dy2 << " " << dx1 << " " << dy2 * dx1 << "\n";
 //Unit exp_x = compute_x_intercept<at>(x11, x21, y11, y21, dy1, dy2, dx1, dx2);
 //Unit exp_y = compute_x_intercept<at>(y11, y21, x11, x21, dx1, dx2, dy1, dy2);
 if(round_closest) {
@@ -573,10 +573,10 @@
 if(is_horizontal(he2))
 y_unit = he2.first.y();
 //if(x != exp_x || y != exp_y)
- // std::cout << exp_x << " " << exp_y << " " << x << " " << y << std::endl;
+ // std::cout << exp_x << " " << exp_y << " " << x << " " << y << "\n";
 //Unit y1 = evalAtXforY(exp_x, he1.first, he1.second);
 //Unit y2 = evalAtXforY(exp_x, he2.first, he2.second);
- //std::cout << exp_x << " " << exp_y << " " << y1 << " " << y2 << std::endl;
+ //std::cout << exp_x << " " << exp_y << " " << y1 << " " << y2 << "\n";
 Point result(x_unit, y_unit);
 if(!contains(rect1, result, true)) return false;
 if(!contains(rect2, result, true)) return false;
@@ -644,8 +644,8 @@
 high_precision y_den = (dx1 * dy2 - dx2 * dy1);
 high_precision x = x_num / x_den;
 high_precision y = y_num / y_den;
- //std::cout << "cross1 " << dy1 << " " << dx2 << " " << dy1 * dx2 << std::endl;
- //std::cout << "cross2 " << dy2 << " " << dx1 << " " << dy2 * dx1 << std::endl;
+ //std::cout << "cross1 " << dy1 << " " << dx2 << " " << dy1 * dx2 << "\n";
+ //std::cout << "cross2 " << dy2 << " " << dx1 << " " << dy2 * dx1 << "\n";
 //Unit exp_x = compute_x_intercept<at>(x11, x21, y11, y21, dy1, dy2, dx1, dx2);
 //Unit exp_y = compute_x_intercept<at>(y11, y21, x11, x21, dx1, dx2, dy1, dy2);
 Unit x_unit = convert_high_precision_type<Unit>(x);
@@ -658,10 +658,10 @@
 if(is_horizontal(he2))
 y_unit = he2.first.y();
 //if(x != exp_x || y != exp_y)
- // std::cout << exp_x << " " << exp_y << " " << x << " " << y << std::endl;
+ // std::cout << exp_x << " " << exp_y << " " << x << " " << y << "\n";
 //Unit y1 = evalAtXforY(exp_x, he1.first, he1.second);
 //Unit y2 = evalAtXforY(exp_x, he2.first, he2.second);
- //std::cout << exp_x << " " << exp_y << " " << y1 << " " << y2 << std::endl;
+ //std::cout << exp_x << " " << exp_y << " " << y1 << " " << y2 << "\n";
 Point result(x_unit, y_unit);
 if(!contains(rect1, result, true)) return false;
 if(!contains(rect2, result, true)) return false;
@@ -1121,21 +1121,21 @@
 typename PolyLineArbitraryByConcept<Unit, typename geometry_concept<typename cT::value_type>::type>::type polyData(at1);
 //poly_line_arbitrary_polygon_data polyData(at1);
 //std::cout << "test2\n";
- //std::cout << poly << std::endl;
+ //std::cout << poly << "\n";
 //std::cout << "test3\n";
 typedef typename cT::value_type result_type;
 typedef typename geometry_concept<result_type>::type result_concept;
 output.push_back(result_type());
 assign(output.back(), polyData);
 //std::cout << "test4\n";
- //std::cout << "delete " << at1->otherTailp_ << std::endl;
+ //std::cout << "delete " << at1->otherTailp_ << "\n";
 //at1->print();
 //at1->otherTailp_->print();
 delete at1->otherTailp_;
 //at1->print();
 //at1->otherTailp_->print();
 //std::cout << "test5\n";
- //std::cout << "delete " << at1 << std::endl;
+ //std::cout << "delete " << at1 << "\n";
 delete at1;
 //std::cout << "test6\n";
 return 0;
@@ -1154,7 +1154,7 @@

 inline void destroyContents() {
 if(otherTailp_) {
- //std::cout << "delete p " << tailp_ << std::endl;
+ //std::cout << "delete p " << tailp_ << "\n";
 if(tailp_) delete tailp_;
 tailp_ = 0;
 otherTailp_->otherTailp_ = 0;
@@ -1162,7 +1162,7 @@
 otherTailp_ = 0;
 }
 for(typename std::list<active_tail_arbitrary*>::iterator itr = holesList_.begin(); itr != holesList_.end(); ++itr) {
- //std::cout << "delete p " << (*itr) << std::endl;
+ //std::cout << "delete p " << (*itr) << "\n";
 if(*itr) {
 if((*itr)->otherTailp_) {
 delete (*itr)->otherTailp_;
@@ -1176,7 +1176,7 @@
 }

 inline void print() {
- //std::cout << this << " " << tailp_ << " " << otherTailp_ << " " << holesList_.size() << " " << head_ << std::endl;
+ //std::cout << this << " " << tailp_ << " " << otherTailp_ << " " << holesList_.size() << " " << head_ << "\n";
 }

 static inline std::pair<active_tail_arbitrary*, active_tail_arbitrary*> createActiveTailsAsPair(Point point, bool solid,
@@ -1356,12 +1356,12 @@
 while(inputBegin != inputEnd) {
 //std::cout << "2\n";
 x_ = (*inputBegin).pt.get(HORIZONTAL);
- //std::cout << "SCAN FORMATION " << x_ << std::endl;
- //std::cout << "x_ = " << x_ << std::endl;
- //std::cout << "scan line size: " << scanData_.size() << std::endl;
+ //std::cout << "SCAN FORMATION " << x_ << "\n";
+ //std::cout << "x_ = " << x_ << "\n";
+ //std::cout << "scan line size: " << scanData_.size() << "\n";
 inputBegin = processEvent_(output, inputBegin, inputEnd);
 }
- //std::cout << "scan line size: " << scanData_.size() << std::endl;
+ //std::cout << "scan line size: " << scanData_.size() << "\n";
 }

 protected:
@@ -1369,7 +1369,7 @@
 template <class cT, class cT2>
 inline std::pair<std::pair<Point, int>, active_tail_arbitrary*> processPoint_(cT& output, cT2& elements, Point point,
 incoming_count& counts_from_scanline, vertex_arbitrary_count& incoming_count) {
- //std::cout << "\nAT POINT: " << point << std::endl;
+ //std::cout << "\nAT POINT: " << point << "\n";
 //join any closing solid corners
 std::vector<int> counts;
 std::vector<int> incoming;
@@ -1401,25 +1401,25 @@
 have_vertical_tail_from_below = true;
 }
 //assert size = size_less_1 + 1
- //std::cout << tails.size() << " " << incoming.size() << " " << counts_from_scanline.size() << " " << incoming_count.size() << std::endl;
+ //std::cout << tails.size() << " " << incoming.size() << " " << counts_from_scanline.size() << " " << incoming_count.size() << "\n";
 // for(std::size_t i = 0; i < counts.size(); ++i) {
 // std::cout << counts_from_scanline[i].first.first.first.get(HORIZONTAL) << ",";
 // std::cout << counts_from_scanline[i].first.first.first.get(VERTICAL) << " ";
 // std::cout << counts_from_scanline[i].first.first.second.get(HORIZONTAL) << ",";
 // std::cout << counts_from_scanline[i].first.first.second.get(VERTICAL) << ":";
 // std::cout << counts_from_scanline[i].first.second << " ";
- // } std::cout << std::endl;
+ // } std::cout << "\n";
 // print(incoming_count);
 {
 for(int i = 0; i < c_size_less_1; ++i) {
- //std::cout << i << std::endl;
+ //std::cout << i << "\n";
 if(counts[i] == -1) {
 //std::cout << "fixed i\n";
 for(int j = i + 1; j < c_size; ++j) {
- //std::cout << j << std::endl;
+ //std::cout << j << "\n";
 if(counts[j]) {
 if(counts[j] == 1) {
- //std::cout << "case1: " << i << " " << j << std::endl;
+ //std::cout << "case1: " << i << " " << j << "\n";
 //if a figure is closed it will be written out by this function to output
 active_tail_arbitrary::joinChains(point, tails[i], tails[j], true, output);
 counts[i] = 0;
@@ -1437,15 +1437,15 @@
 //std::cout << "checking case2\n";
 {
 for(int i = 0; i < i_size_less_1; ++i) {
- //std::cout << i << std::endl;
+ //std::cout << i << "\n";
 if(incoming[i] == 1) {
 //std::cout << "fixed i\n";
 for(int j = i + 1; j < i_size; ++j) {
- //std::cout << j << std::endl;
+ //std::cout << j << "\n";
 if(incoming[j]) {
- //std::cout << incoming[j] << std::endl;
+ //std::cout << incoming[j] << "\n";
 if(incoming[j] == -1) {
- //std::cout << "case2: " << i << " " << j << std::endl;
+ //std::cout << "case2: " < tailPair =
 active_tail_arbitrary::createActiveTailsAsPair(point, true, 0, fractureHoles_ != 0);
@@ -1457,14 +1457,14 @@
 returnCount.first = point;
 returnCount.second = 1;
 } else {
- //std::cout << "new element " << j-1 << " " << -1 << std::endl;
- //std::cout << point << " " << incoming_count[j].first << std::endl;
+ //std::cout << "new element " << j-1 << " " << -1 << "\n";
+ //std::cout << point << " " << incoming_count[j].first << "\n";
 elements.push_back(std::pair<vertex_half_edge,
 active_tail_arbitrary*>(vertex_half_edge(point,
 incoming_count[j].first, -1), tailPair.first));
 }
- //std::cout << "new element " << i-1 << " " << 1 << std::endl;
- //std::cout << point << " " << incoming_count[i].first << std::endl;
+ //std::cout << "new element " << i-1 << " " << 1 << "\n";
+ //std::cout << point << " " << incoming_count[i].first << "\n";
 elements.push_back(std::pair<vertex_half_edge,
 active_tail_arbitrary*>(vertex_half_edge(point,
 incoming_count[i].first, 1), tailPair.second));
@@ -1484,14 +1484,14 @@
 {
 //std::cout << "checking case 3\n";
 for(int i = 0; i < c_size; ++i) {
- //std::cout <= 0; --j) {
 if(incoming[j] != 0) {
 if(incoming[j] == 1) {
- //std::cout << "case3: " <print();
 //pass through solid on top
 tails[i]->pushPoint(point);
@@ -1521,13 +1521,13 @@
 //find pass through with solid on bottom
 {
 for(int i = c_size_less_1; i >= 0; --i) {
- //std::cout << "i = " << i << " with count " << counts[i] << std::endl;
+ //std::cout << "i = " << i << " with count " << counts[i] << "\n";
 if(counts[i] != 0) {
 if(counts[i] == -1) {
 for(int j = 0; j < i_size; ++j) {
 if(incoming[j] != 0) {
 if(incoming[j] == -1) {
- //std::cout << "case4: " <pushPoint(point);
 if(j == i_size_less_1 && incoming_count[j].first.get(HORIZONTAL) == point.get(HORIZONTAL)) {
@@ -1535,8 +1535,8 @@
 returnCount.first = point;
 returnCount.second = 1;
 } else {
- //std::cout << "new element " << j-1 << " " << incoming[j] << std::endl;
- //std::cout << point << " " << incoming_count[j].first << std::endl;
+ //std::cout << "new element " << j-1 << " " << incoming[j] << "\n";
+ //std::cout << point << " " << incoming_count[j].first << "\n";
 elements.push_back(std::pair<vertex_half_edge,
 active_tail_arbitrary*>(vertex_half_edge(point,
 incoming_count[j].first, incoming[j]), tails[i]));
@@ -1561,11 +1561,11 @@
 if(counts[i] != 0) {
 for(int j = i+1; j < c_size; ++j) {
 if(counts[j] != 0) {
- //std::cout << "case5: " << i << " " << j << std::endl;
+ //std::cout << "case5: " << i << " " << j << "\n";
 //we are ending a hole and may potentially close a figure and have to handle the hole
 returnValue = active_tail_arbitrary::joinChains(point, tails[i], tails[j], false, output);
 if(returnValue) returnCount.first = point;
- //std::cout << returnValue << std::endl;
+ //std::cout << returnValue << "\n";
 tails[i] = 0;
 tails[j] = 0;
 counts[i] = 0;
@@ -1583,7 +1583,7 @@
 if(incoming[i] != 0) {
 for(int j = i+1; j < i_size; ++j) {
 if(incoming[j] != 0) {
- //std::cout << "case6: " << i << " " << j << std::endl;
+ //std::cout << "case6: " << i << " " << j << "\n";
 //we are beginning a empty space
 active_tail_arbitrary* holep = 0;
 //if(c_size && counts[c_size_less_1] == 0 &&
@@ -1596,20 +1596,20 @@
 std::pair<active_tail_arbitrary*, active_tail_arbitrary*> tailPair =
 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;
+ //std::cout << "vertical element " << point << "\n";
 returnValue = tailPair.first;
 returnCount.first = point;
 //returnCount = incoming_count[j];
 returnCount.second = -1;
 } else {
- //std::cout << "new element " << j-1 << " " << incoming[j] << std::endl;
- //std::cout << point << " " << incoming_count[j].first << std::endl;
+ //std::cout << "new element " << j-1 << " " << incoming[j] << "\n";
+ //std::cout << point << " " << incoming_count[j].first << "\n";
 elements.push_back(std::pair<vertex_half_edge,
 active_tail_arbitrary*>(vertex_half_edge(point,
 incoming_count[j].first, incoming[j]), tailPair.first));
 }
- //std::cout << "new element " << i-1 << " " << incoming[i] << std::endl;
- //std::cout << point << " " << incoming_count[i].first << std::endl;
+ //std::cout << "new element " << i-1 << " " << incoming[i] << "\n";
+ //std::cout << point << " " << incoming_count[i].first << "\n";
 elements.push_back(std::pair<vertex_half_edge,
 active_tail_arbitrary*>(vertex_half_edge(point,
 incoming_count[i].first, incoming[i]), tailPair.second));
@@ -1639,13 +1639,13 @@
 //std::cout << count[i].first.get(HORIZONTAL) << ",";
 //std::cout << count[i].first.get(VERTICAL) << ":";
 //std::cout << count[i].second << " ";
- } //std::cout << std::endl;
+ } //std::cout << "\n";
 }

 static inline void print(const scanline_data& data) {
 for(typename scanline_data::const_iterator itr = data.begin(); itr != data.end(); ++itr){
 //std::cout << itr->first.pt << ", " << itr->first.other_pt << "; ";
- } //std::cout << std::endl;
+ } //std::cout << "\n";
 }

 template <class cT, class iT>
@@ -1664,16 +1664,16 @@
 while(currentIter != inputEnd && currentIter->pt.get(HORIZONTAL) == x_) {
 //std::cout << "loop\n";
 Unit currentY = (*currentIter).pt.get(VERTICAL);
- //std::cout << "current Y " << currentY << std::endl;
- //std::cout << "scanline size " << scanData_.size() << std::endl;
+ //std::cout << "current Y " << currentY << "\n";
+ //std::cout << "scanline size " << scanData_.size() << "\n";
 //print(scanData_);
 iterator iter = lookUp_(currentY);
- //std::cout << "found element in scanline " << (iter != scanData_.end()) << std::endl;
+ //std::cout << "found element in scanline " << (iter != scanData_.end()) << "\n";
 //int counts[4] = {0, 0, 0, 0};
 incoming_count counts_from_scanline;
 //std::cout << "finding elements in tree\n";
 //if(iter != scanData_.end())
- // std::cout << "first iter y is " << iter->first.evalAtX(x_) << std::endl;
+ // std::cout << "first iter y is " << iter->first.evalAtX(x_) << "\n";
 while(iter != scanData_.end() &&
 ((iter->first.pt.x() == x_ && iter->first.pt.y() == currentY) ||
 (iter->first.other_pt.x() == x_ && iter->first.other_pt.y() == currentY))) {
@@ -1688,7 +1688,7 @@
 ++iter;
 }
 Point currentPoint(x_, currentY);
- //std::cout << "counts_from_scanline size " << counts_from_scanline.size() << std::endl;
+ //std::cout << "counts_from_scanline size " << counts_from_scanline.size() << "\n";
 sort_incoming_count(counts_from_scanline, currentPoint);

 vertex_arbitrary_count incoming;
@@ -1702,9 +1702,9 @@
 currentIter->pt.get(HORIZONTAL) == x_);
 //print(incoming);
 sort_vertex_arbitrary_count(incoming, currentPoint);
- //std::cout << currentPoint.get(HORIZONTAL) << "," << currentPoint.get(VERTICAL) << std::endl;
+ //std::cout << currentPoint.get(HORIZONTAL) << "," << currentPoint.get(VERTICAL) << "\n";
 //print(incoming);
- //std::cout << "incoming counts from input size " << incoming.size() << std::endl;
+ //std::cout << "incoming counts from input size " << incoming.size() << "\n";
 //compact_vertex_arbitrary_count(currentPoint, incoming);
 vertex_arbitrary_count tmp;
 tmp.reserve(incoming.size());
@@ -1714,13 +1714,13 @@
 }
 }
 incoming.swap(tmp);
- //std::cout << "incoming counts from input size " << incoming.size() << std::endl;
+ //std::cout << "incoming counts from input size " << incoming.size() << "\n";
 //now counts_from_scanline has the data from the left and
 //incoming has the data from the right at this point
 //cancel out any end points
 if(verticalTail) {
 //std::cout << "adding vertical tail to counts from scanline\n";
- //std::cout << -verticalCount.second << std::endl;
+ //std::cout << -verticalCount.second << "\n";
 counts_from_scanline.push_back(std::pair<std::pair<std::pair<Point, Point>, int>, active_tail_arbitrary*>
 (std::pair<std::pair<Point, Point>, int>(std::pair<Point, Point>(verticalCount.first,
 currentPoint),
@@ -1737,7 +1737,7 @@
 verticalTail = result.second;
 //if(verticalTail) {
 // std::cout << "have vertical tail\n";
- // std::cout << verticalCount.second << std::endl;
+ // std::cout << verticalCount.second << "\n";
 //}
 if(verticalTail && !(verticalCount.second)) {
 //we got a hole out of the point we just processed
@@ -1794,7 +1794,7 @@

 inline iterator lookUp_(Unit y){
 //if just before then we need to look from 1 not -1
- //std::cout << "just before " << justBefore_ << std::endl;
+ //std::cout << "just before " << justBefore_ << "\n";
 return scanData_.lower_bound(vertex_half_edge(Point(x_, y), Point(x_, y+1), 0));
 }

@@ -1816,9 +1816,9 @@
 data.push_back(vertex_half_edge(Point(10, 10), Point(0, 10), 1));
 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon formation\n";
 return true;
@@ -1840,9 +1840,9 @@
 data.push_back(vertex_half_edge(Point(10, 20), Point(0, 10), 1));
 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon formation\n";
 return true;
@@ -1864,9 +1864,9 @@
 data.push_back(vertex_half_edge(Point(2, 4), Point(2, -4), 1));
 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon formation\n";
 return true;
@@ -1910,14 +1910,14 @@

 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 pf2.scan(polys2, data.begin(), data.end());
- stdcout << "result size: " << polys2.size() << std::endl;
+ stdcout << "result size: " << polys2.size() << "\n";
 for(std::size_t i = 0; i < polys2.size(); ++i) {
- stdcout << polys2[i] << std::endl;
+ stdcout << polys2[i] << "\n";
 }
 stdcout << "done testing polygon formation\n";
 return true;
@@ -1957,9 +1957,9 @@

 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon formation\n";
 return true;
@@ -1997,9 +1997,9 @@

 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon formation\n";
 return true;
@@ -2037,9 +2037,9 @@

 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon formation\n";
 return true;
@@ -2065,9 +2065,9 @@
 data.push_back(vertex_half_edge(Point(0, 2), Point(-1, 4), 1));
 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing polygon formation\n";
 return true;
@@ -2281,12 +2281,12 @@
 while(inputBegin != inputEnd) {
 //std::cout << "2\n";
 polygon_arbitrary_formation<Unit>::x_ = (*inputBegin).pt.get(HORIZONTAL);
- //std::cout << "SCAN FORMATION " << x_ << std::endl;
- //std::cout << "x_ = " << x_ << std::endl;
- //std::cout << "scan line size: " << scanData_.size() << std::endl;
+ //std::cout << "SCAN FORMATION " << x_ << "\n";
+ //std::cout << "x_ = " << x_ << "\n";
+ //std::cout << "scan line size: " << scanData_.size() << "\n";
 inputBegin = processEvent_(output, inputBegin, inputEnd);
 }
- //std::cout << "scan line size: " << scanData_.size() << std::endl;
+ //std::cout << "scan line size: " << scanData_.size() << "\n";
 }

 private:
@@ -2311,7 +2311,7 @@
 std::pair<active_tail_arbitrary*, active_tail_arbitrary*>& verticalPair,
 iterator previter, Point point, incoming_count& counts_from_scanline,
 vertex_arbitrary_count& incoming_count) {
- //std::cout << "\nAT POINT: " << point << std::endl;
+ //std::cout << "\nAT POINT: " << point << "\n";
 //join any closing solid corners
 std::vector<int> counts;
 std::vector<int> incoming;
@@ -2346,25 +2346,25 @@
 have_vertical_tail_from_below = true;
 }
 //assert size = size_less_1 + 1
- //std::cout << tails.size() << " " << incoming.size() << " " << counts_from_scanline.size() << " " << incoming_count.size() << std::endl;
+ //std::cout << tails.size() << " " << incoming.size() << " " << counts_from_scanline.size() << " " << incoming_count.size() << "\n";
 // for(std::size_t i = 0; i < counts.size(); ++i) {
 // std::cout << counts_from_scanline[i].first.first.first.get(HORIZONTAL) << ",";
 // std::cout << counts_from_scanline[i].first.first.first.get(VERTICAL) << " ";
 // std::cout << counts_from_scanline[i].first.first.second.get(HORIZONTAL) << ",";
 // std::cout << counts_from_scanline[i].first.first.second.get(VERTICAL) << ":";
 // std::cout << counts_from_scanline[i].first.second << " ";
- // } std::cout << std::endl;
+ // } std::cout << "\n";
 // print(incoming_count);
 {
 for(int i = 0; i < c_size_less_1; ++i) {
- //std::cout << i << std::endl;
+ //std::cout << i << "\n";
 if(counts[i] == -1) {
 //std::cout << "fixed i\n";
 for(int j = i + 1; j < c_size; ++j) {
- //std::cout << j << std::endl;
+ //std::cout << j << "\n";
 if(counts[j]) {
 if(counts[j] == 1) {
- //std::cout << "case1: " << i << " " << j << std::endl;
+ //std::cout << "case1: " << i << " " << j << "\n";
 //if a figure is closed it will be written out by this function to output
 active_tail_arbitrary::joinChains(point, tails[i], tails[j], true, output);
 counts[i] = 0;
@@ -2382,15 +2382,15 @@
 //std::cout << "checking case2\n";
 {
 for(int i = 0; i < i_size_less_1; ++i) {
- //std::cout << i << std::endl;
+ //std::cout << i << "\n";
 if(incoming[i] == 1) {
 //std::cout << "fixed i\n";
 for(int j = i + 1; j < i_size; ++j) {
- //std::cout << j << std::endl;
+ //std::cout << j << "\n";
 if(incoming[j]) {
- //std::cout << incoming[j] << std::endl;
+ //std::cout << incoming[j] << "\n";
 if(incoming[j] == -1) {
- //std::cout << "case2: " << i << " " << j << std::endl;
+ //std::cout << "case2: " < tailPair =
 active_tail_arbitrary::createActiveTailsAsPair(point, true, 0, polygon_arbitrary_formation<Unit>::fractureHoles_ != 0);
@@ -2402,14 +2402,14 @@
 returnCount.first = point;
 returnCount.second = 1;
 } else {
- //std::cout << "new element " << j-1 << " " << -1 << std::endl;
- //std::cout << point << " " << incoming_count[j].first << std::endl;
+ //std::cout << "new element " << j-1 << " " << -1 << "\n";
+ //std::cout << point << " " << incoming_count[j].first << "\n";
 elements.push_back(std::pair<vertex_half_edge,
 active_tail_arbitrary*>(vertex_half_edge(point,
 incoming_count[j].first, -1), tailPair.first));
 }
- //std::cout << "new element " << i-1 << " " << 1 << std::endl;
- //std::cout << point << " " << incoming_count[i].first << std::endl;
+ //std::cout << "new element " << i-1 << " " << 1 << "\n";
+ //std::cout << point << " " << incoming_count[i].first << "\n";
 elements.push_back(std::pair<vertex_half_edge,
 active_tail_arbitrary*>(vertex_half_edge(point,
 incoming_count[i].first, 1), tailPair.second));
@@ -2429,14 +2429,14 @@
 {
 //std::cout << "checking case 3\n";
 for(int i = 0; i < c_size; ++i) {
- //std::cout <= 0; --j) {
 if(incoming[j] != 0) {
 if(incoming[j] == 1) {
- //std::cout << "case3: " <print();
 //pass through solid on top
 tails[i]->pushPoint(point);
@@ -2470,13 +2470,13 @@
 //find pass through with solid on bottom
 {
 for(int i = c_size_less_1; i >= 0; --i) {
- //std::cout << "i = " << i << " with count " << counts[i] << std::endl;
+ //std::cout << "i = " << i << " with count " << counts[i] << "\n";
 if(counts[i] != 0) {
 if(counts[i] == -1) {
 for(int j = 0; j < i_size; ++j) {
 if(incoming[j] != 0) {
 if(incoming[j] == -1) {
- //std::cout << "case4: " << i << " " << j << std::endl;
+ //std::cout << "case4: " << i << " " << j << "\n";
 //pass through solid on bottom

 //if count from scanline is vertical
@@ -2536,7 +2536,7 @@
 if(counts[i] != 0) {
 for(int j = i+1; j < c_size; ++j) {
 if(counts[j] != 0) {
- //std::cout << "case5: " << i << " " << j << std::endl;
+ //std::cout << "case5: " <pushPoint(point);
 verticalPairOut.first = tails[i];
@@ -2569,7 +2569,7 @@
 if(incoming[i] != 0) {
 for(int j = i+1; j < i_size; ++j) {
 if(incoming[j] != 0) {
- //std::cout << "case6: " << i << " " << j << std::endl;
+ //std::cout << "case6: " << i << " " << j << "\n";
 //we are beginning a empty space
 if(verticalPair.first == 0) {
 getVerticalPair_(verticalPair, previter);
@@ -2619,13 +2619,13 @@
 //std::cout << count[i].first.get(HORIZONTAL) << ",";
 //std::cout << count[i].first.get(VERTICAL) << ":";
 //std::cout << count[i].second << " ";
- } //std::cout << std::endl;
+ } //std::cout << "\n";
 }

 static inline void print(const scanline_data& data) {
 for(typename scanline_data::const_iterator itr = data.begin(); itr != data.end(); ++itr){
 //std::cout << itr->first.pt << ", " << itr->first.other_pt << "; ";
- } //std::cout << std::endl;
+ } //std::cout << "\n";
 }

 template <class cT, class iT>
@@ -2645,16 +2645,16 @@
 while(currentIter != inputEnd && currentIter->pt.get(HORIZONTAL) == polygon_arbitrary_formation<Unit>::x_) {
 //std::cout << "loop\n";
 Unit currentY = (*currentIter).pt.get(VERTICAL);
- //std::cout << "current Y " << currentY << std::endl;
- //std::cout << "scanline size " << scanData_.size() << std::endl;
+ //std::cout << "current Y " << currentY << "\n";
+ //std::cout << "scanline size " << scanData_.size() << "\n";
 //print(scanData_);
 iterator iter = this->lookUp_(currentY);
- //std::cout << "found element in scanline " << (iter != scanData_.end()) << std::endl;
+ //std::cout << "found element in scanline " << (iter != scanData_.end()) << "\n";
 //int counts[4] = {0, 0, 0, 0};
 incoming_count counts_from_scanline;
 //std::cout << "finding elements in tree\n";
 //if(iter != scanData_.end())
- // std::cout << "first iter y is " << iter->first.evalAtX(x_) << std::endl;
+ // std::cout << "first iter y is " << iter->first.evalAtX(x_) << "\n";
 iterator previter = iter;
 if(previter != polygon_arbitrary_formation<Unit>::scanData_.end() &&
 previter->first.evalAtX(polygon_arbitrary_formation<Unit>::x_) >= currentY &&
@@ -2674,7 +2674,7 @@
 ++iter;
 }
 Point currentPoint(polygon_arbitrary_formation<Unit>::x_, currentY);
- //std::cout << "counts_from_scanline size " << counts_from_scanline.size() << std::endl;
+ //std::cout << "counts_from_scanline size " << counts_from_scanline.size() << "\n";
 this->sort_incoming_count(counts_from_scanline, currentPoint);

 vertex_arbitrary_count incoming;
@@ -2688,9 +2688,9 @@
 currentIter->pt.get(HORIZONTAL) == polygon_arbitrary_formation<Unit>::x_);
 //print(incoming);
 this->sort_vertex_arbitrary_count(incoming, currentPoint);
- //std::cout << currentPoint.get(HORIZONTAL) << "," << currentPoint.get(VERTICAL) << std::endl;
+ //std::cout << currentPoint.get(HORIZONTAL) << "," << currentPoint.get(VERTICAL) << "\n";
 //print(incoming);
- //std::cout << "incoming counts from input size " << incoming.size() << std::endl;
+ //std::cout << "incoming counts from input size " << incoming.size() << "\n";
 //compact_vertex_arbitrary_count(currentPoint, incoming);
 vertex_arbitrary_count tmp;
 tmp.reserve(incoming.size());
@@ -2700,13 +2700,13 @@
 }
 }
 incoming.swap(tmp);
- //std::cout << "incoming counts from input size " << incoming.size() << std::endl;
+ //std::cout << "incoming counts from input size " << incoming.size() << "\n";
 //now counts_from_scanline has the data from the left and
 //incoming has the data from the right at this point
 //cancel out any end points
 if(verticalTail) {
 //std::cout << "adding vertical tail to counts from scanline\n";
- //std::cout << -verticalCount.second << std::endl;
+ //std::cout << -verticalCount.second << "\n";
 counts_from_scanline.push_back(std::pair<std::pair<std::pair<Point, Point>, int>, active_tail_arbitrary*>
 (std::pair<std::pair<Point, Point>, int>(std::pair<Point, Point>(verticalCount.first,
 currentPoint),
@@ -2771,9 +2771,9 @@
 data.push_back(vertex_half_edge(Point(10, 10), Point(0, 10), 1));
 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing trapezoid formation\n";
 return true;
@@ -2794,9 +2794,9 @@
 data.push_back(vertex_half_edge(Point(10, 20), Point(0, 10), 1));
 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing trapezoid formation\n";
 return true;
@@ -2817,9 +2817,9 @@
 data.push_back(vertex_half_edge(Point(2, 4), Point(2, -4), 1));
 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing trapezoid formation\n";
 return true;
@@ -2862,14 +2862,14 @@

 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 //pf2.scan(polys2, data.begin(), data.end());
- //stdcout << "result size: " << polys2.size() << std::endl;
+ //stdcout << "result size: " << polys2.size() << "\n";
 //for(std::size_t i = 0; i < polys2.size(); ++i) {
- // stdcout << polys2[i] << std::endl;
+ // stdcout << polys2[i] << "\n";
 //}
 stdcout << "done testing trapezoid formation\n";
 return true;
@@ -2909,9 +2909,9 @@

 polygon_sort(data.begin(), data.end());
 pf.scan(polys, data.begin(), data.end());
- stdcout << "result size: " << polys.size() << std::endl;
+ stdcout << "result size: " << polys.size() << "\n";
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 stdcout << "done testing trapezoid formation\n";
 return true;

Modified: trunk/boost/polygon/detail/scan_arbitrary.hpp
==============================================================================
--- trunk/boost/polygon/detail/scan_arbitrary.hpp (original)
+++ trunk/boost/polygon/detail/scan_arbitrary.hpp 2012-09-18 20:26:14 EDT (Tue, 18 Sep 2012)
@@ -269,11 +269,11 @@
// for(typename std::set<Point>::iterator itr = intersection_points[offenders.first].begin();
// itr != intersection_points[offenders.first].end(); ++itr) {
// std::cout << (*itr).x() << " " << (*itr).y() << " ";
-// } std::cout << std::endl;
+// } std::cout << "\n";
// for(typename std::set<Point>::iterator itr = intersection_points[offenders.second].begin();
// itr != intersection_points[offenders.second].end(); ++itr) {
// std::cout << (*itr).x() << " " << (*itr).y() << " ";
-// } std::cout << std::endl;
+// } std::cout << "\n";
// exit(1);
// }
 }
@@ -307,7 +307,7 @@
 if(scanline_base<Unit>::intersects(he1, he2)) {
 offenders.first = id1;
 offenders.second = id2;
- //std::cout << he1.first.x() << " " << he1.first.y() << " " << he1.second.x() << " " << he1.second.y() << " " << he2.first.x() << " " << he2.first.y() << " " << he2.second.x() << " " << he2.second.y() << std::endl;
+ //std::cout << he1.first.x() << " " << he1.first.y() << " " << he1.second.x() << " " << he1.second.y() << " " << he2.first.x() << " " << he2.first.y() << " " << he2.second.x() << " " << he2.second.y() << "\n";
 return false;
 }
 }
@@ -693,7 +693,7 @@
 }
 edges.clear();
 validate_scan(edges, input.begin(), input.end());
- stdcout << edges.size() << std::endl;
+ stdcout << edges.size() << "\n";
 if(!verify_scan(result, edges.begin(), edges.end())) {
 stdcout << "s fail5 3 " << result.first << " " << result.second << "\n";
 return false;
@@ -876,7 +876,7 @@
 for(std::size_t i = 0; i < vec.size(); ++ i) {
 // print(vec[i]);
 }
- //std::cout << std::endl;
+ //std::cout << "\n";
 }

 template <typename stream_type>
@@ -1012,7 +1012,7 @@
 void write_out(result_type& result, result_functor rf, const half_edge& he,
 const property_map& pm_left, const property_map& pm_right) {
 //std::cout << "write out ";
- //std::cout << he.first << ", " << he.second << std::endl;
+ //std::cout << he.first << ", " << he.second << "\n";
 property_set ps_left, ps_right;
 set_unique_property(ps_left, pm_left);
 set_unique_property(ps_right, pm_right);
@@ -1230,7 +1230,7 @@
 // for(std::size_t i = 0; i < mp.size(); ++i) {
 // std::cout << mp[i].first << ":" << mp[i].second << " ";
 // } std::cout << ") ";
- // } std::cout << std::endl;
+ // } std::cout << "\n";
 //}

 static inline void merge_property_maps(property_map& mp, const property_map& mp2) {
@@ -1338,7 +1338,7 @@
 stdcout << "scanned\n";
 for(std::size_t i = 0; i < result.size(); ++i) {
 stdcout << result[i].first.first << ", " << result[i].first.second << "; ";
- } stdcout << std::endl;
+ } stdcout << "\n";
 input.clear();
 result.clear();
 input.push_back(std::make_pair(half_edge(Point(-1, -1), Point(10, 0)), std::make_pair(0, 1)));
@@ -1350,7 +1350,7 @@
 stdcout << "scanned\n";
 for(std::size_t i = 0; i < result.size(); ++i) {
 stdcout << result[i].first.first << ", " << result[i].first.second << "; ";
- } stdcout << std::endl;
+ } stdcout << "\n";
 input.clear();
 result.clear();
 input.push_back(std::make_pair(half_edge(Point(0, 0), Point(0, 10)), std::make_pair(0, 1)));
@@ -1366,7 +1366,7 @@
 stdcout << "scanned\n";
 for(std::size_t i = 0; i < result.size(); ++i) {
 stdcout << result[i].first.first << ", " << result[i].first.second << "; ";
- } stdcout << std::endl;
+ } stdcout << "\n";
 input.clear();
 result.clear();
 input.push_back(std::make_pair(half_edge(Point(0, 0), Point(0, 10)), std::make_pair(0, 1)));
@@ -1382,7 +1382,7 @@
 stdcout << "scanned\n";
 for(std::size_t i = 0; i < result.size(); ++i) {
 stdcout << result[i].first.first << ", " << result[i].first.second << "; ";
- } stdcout << std::endl;
+ } stdcout << "\n";
 input.clear();
 result.clear();
 input.push_back(std::make_pair(half_edge(Point(0, 0), Point(10, 0)), std::make_pair(0, 1)));
@@ -1398,7 +1398,7 @@
 stdcout << "scanned\n";
 for(std::size_t i = 0; i < result.size(); ++i) {
 stdcout << result[i].first.first << ", " << result[i].first.second << "; ";
- } stdcout << std::endl;
+ } stdcout << "\n";
 input.clear();
 result.clear();
 input.push_back(std::make_pair(half_edge(Point(0, 0), Point(10, 0)), std::make_pair(0, 1)));
@@ -1414,7 +1414,7 @@
 stdcout << "scanned\n";
 for(std::size_t i = 0; i < result.size(); ++i) {
 stdcout << result[i].first.first << ", " << result[i].first.second << "; ";
- } stdcout << std::endl;
+ } stdcout << "\n";
 input.clear();
 result.clear();
 input.push_back(std::make_pair(half_edge(Point(0, 0), Point(10, 0)), std::make_pair(0, 1)));
@@ -1438,7 +1438,7 @@
 stdcout << "scanned\n";
 for(std::size_t i = 0; i < result.size(); ++i) {
 stdcout << result[i].first.first << ", " << result[i].first.second << "; ";
- } stdcout << std::endl;
+ } stdcout << "\n";
 input.clear();
 result.clear();
 input.push_back(std::make_pair(half_edge(Point(-1, -1), Point(10, 0)), std::make_pair(0, 1))); //a
@@ -1458,7 +1458,7 @@
 stdcout << "scanned\n";
 for(std::size_t i = 0; i < result.size(); ++i) {
 stdcout << result[i].first.first << ", " << result[i].first.second << "; ";
- } stdcout << std::endl;
+ } stdcout << "\n";
 return true;
 }

@@ -1568,7 +1568,7 @@
 }
 if(!line_intersection<Unit>::verify_scan(offenders, lines.begin(), lines.end())) {
 //stdcout << "Intersection failed!\n";
- //stdcout << offenders.first << " " << offenders.second << std::endl;
+ //stdcout << offenders.first << " " << offenders.second << "\n";
 return false;
 }
 std::vector<Point> pts;
@@ -1790,7 +1790,7 @@
 yh(rect, 11);

 si.insert(rect, 333);
- print(stdcout, si.pmd) << std::endl;
+ print(stdcout, si.pmd) << "\n";

 Point pts[4] = {Point(0, 0), Point(10,-3), Point(13, 8), Point(0, 0) };
 polygon_data<Unit> poly;
@@ -1798,25 +1798,25 @@
 poly.set(pts, pts+3);
 si2.insert(poly, 444);
 si2.sort_property_merge_data();
- print(stdcout, si2.pmd) << std::endl;
+ print(stdcout, si2.pmd) << "\n";
 property_merge si3;
 poly.set(pts, pts+4);
 si3.insert(poly, 444);
 si3.sort_property_merge_data();
- stdcout << (si2.pmd == si3.pmd) << std::endl;
+ stdcout << (si2.pmd == si3.pmd) << "\n";
 std::reverse(pts, pts+4);
 property_merge si4;
 poly.set(pts, pts+4);
 si4.insert(poly, 444);
 si4.sort_property_merge_data();
- print(stdcout, si4.pmd) << std::endl;
- stdcout << (si2.pmd == si4.pmd) << std::endl;
+ print(stdcout, si4.pmd) << "\n";
+ stdcout << (si2.pmd == si4.pmd) << "\n";
 std::reverse(pts, pts+3);
 property_merge si5;
 poly.set(pts, pts+4);
 si5.insert(poly, 444);
 si5.sort_property_merge_data();
- stdcout << (si2.pmd == si5.pmd) << std::endl;
+ stdcout << (si2.pmd == si5.pmd) << "\n";

 return true;
 }
@@ -1833,7 +1833,7 @@
 si.insert(rect, 333);
 std::map<std::set<property_type>, polygon_set_data<Unit> > result;
 si.merge(result);
- print(stdcout, si.pmd) << std::endl;
+ print(stdcout, si.pmd) << "\n";
 polygon_set_data<Unit> psd = (*(result.begin())).second;
 std::vector<polygon_data<Unit> > polys;
 psd.get(polys);
@@ -1841,7 +1841,7 @@
 stdcout << "fail merge 1\n";
 return false;
 }
- stdcout << (polys[0]) << std::endl;
+ stdcout << (polys[0]) << "\n";
 si.clear();
 std::vector<Point> pts;
 pts.push_back(Point(0, 0));
@@ -1858,9 +1858,9 @@
 si.insert(poly, 444);
 result.clear();
 si.merge(result);
- print(stdcout, si.pmd) << std::endl;
+ print(stdcout, si.pmd) << "\n";
 psd = (*(result.begin())).second;
- stdcout << psd << std::endl;
+ stdcout << psd << "\n";
 polys.clear();
 psd.get(polys);
 if(polys.size() != 1) {
@@ -1884,9 +1884,9 @@
 si.insert(poly, 444);
 result.clear();
 si.merge(result);
- print(stdcout, si.pmd) << std::endl;
+ print(stdcout, si.pmd) << "\n";
 psd = (*(result.begin())).second;
- stdcout << psd << std::endl;
+ stdcout << psd << "\n";
 polys.clear();
 psd.get(polys);
 if(polys.size() != 1) {
@@ -1910,16 +1910,16 @@
 si.insert(poly, 444);
 result.clear();
 si.merge(result);
- print(stdcout, si.pmd) << std::endl;
+ print(stdcout, si.pmd) << "\n";
 psd = (*(result.begin())).second;
- stdcout << psd << std::endl;
+ stdcout << psd << "\n";
 polys.clear();
 psd.get(polys);
 if(polys.size() != 1) {
 stdcout << "fail merge 4\n";
 return false;
 }
- stdcout << (polys[0]) << std::endl;
+ stdcout << (polys[0]) << "\n";
 stdcout << "Polygon { -4 0, -2 -3, 3 -4 } \n";
 stdcout << "Polygon { -1 1, 1 -2, -4 -3 } \n";
 si.clear();
@@ -1937,9 +1937,9 @@
 si.insert(poly, 444);
 result.clear();
 si.merge(result);
- print(stdcout, si.pmd) << std::endl;
+ print(stdcout, si.pmd) << "\n";
 psd = (*(result.begin())).second;
- stdcout << psd << std::endl;
+ stdcout << psd << "\n";
 polys.clear();
 psd.get(polys);
 if(polys.size() != 1) {
@@ -1963,17 +1963,17 @@
 si.insert(poly, 444);
 result.clear();
 si.merge(result);
- print(stdcout, si.pmd) << std::endl;
+ print(stdcout, si.pmd) << "\n";
 if(!result.empty()) {
 psd = (*(result.begin())).second;
- stdcout << psd << std::endl;
+ stdcout << psd << "\n";
 polys.clear();
 psd.get(polys);
 if(polys.size() != 1) {
 stdcout << "fail merge 6\n";
 return false;
 }
- stdcout << (polys[0]) << std::endl;
+ stdcout << (polys[0]) << "\n";
 }
 stdcout << "Polygon { 0 2, 3 -1, 4 1 } \n";
 stdcout << "Polygon { -4 3, 3 3, 4 2 } \n";
@@ -1992,17 +1992,17 @@
 si.insert(poly, 444);
 result.clear();
 si.merge(result);
- print(stdcout, si.pmd) << std::endl;
+ print(stdcout, si.pmd) << "\n";
 if(!result.empty()) {
 psd = (*(result.begin())).second;
- stdcout << psd << std::endl;
+ stdcout << psd << "\n";
 polys.clear();
 psd.get(polys);
 if(polys.size() == 0) {
 stdcout << "fail merge 7\n";
 return false;
 }
- stdcout << (polys[0]) << std::endl;
+ stdcout << (polys[0]) << "\n";
 }
stdcout << "Polygon { 1 -2, -1 4, 3 -2 } \n";
stdcout << "Polygon { 0 -3, 3 1, -3 -4 } \n";
@@ -2021,17 +2021,17 @@
 si.insert(poly, 444);
 result.clear();
 si.merge(result);
- print(stdcout, si.pmd) << std::endl;
+ print(stdcout, si.pmd) << "\n";
 if(!result.empty()) {
 psd = (*(result.begin())).second;
- stdcout << psd << std::endl;
+ stdcout << psd << "\n";
 polys.clear();
 psd.get(polys);
 if(polys.size() == 0) {
 stdcout << "fail merge 8\n";
 return false;
 }
- stdcout << (polys[0]) << std::endl;
+ stdcout << (polys[0]) << "\n";
 }
stdcout << "Polygon { 2 2, 3 0, -3 4 } \n";
stdcout << "Polygon { -2 -2, 0 0, -1 -1 } \n";
@@ -2050,17 +2050,17 @@
 si.insert(poly, 444);
 result.clear();
 si.merge(result);
- print(stdcout, si.pmd) << std::endl;
+ print(stdcout, si.pmd) << "\n";
 if(!result.empty()) {
 psd = (*(result.begin())).second;
- stdcout << psd << std::endl;
+ stdcout << psd << "\n";
 polys.clear();
 psd.get(polys);
 if(polys.size() == 0) {
 stdcout << "fail merge 9\n";
 return false;
 }
- stdcout << (polys[0]) << std::endl;
+ stdcout << (polys[0]) << "\n";
 }
 si.clear();
 pts.clear();
@@ -2158,10 +2158,10 @@
 result.clear();
 si.merge(result);
 si.verify1();
- print(stdcout, si.pmd) << std::endl;
+ print(stdcout, si.pmd) << "\n";
 if(!result.empty()) {
 psd = (*(result.begin())).second;
- stdcout << psd << std::endl;
+ stdcout << psd << "\n";
 std::vector<Point> outpts;
 for(typename polygon_set_data<Unit>::iterator_type itr = psd.begin();
 itr != psd.end(); ++itr) {
@@ -2172,8 +2172,8 @@
 for(std::size_t i = 0; i < outpts.size(); i+=2) {
 if(outpts[i] != outpts[i+1]) {
 stdcout << "Polygon set not a closed figure\n";
- stdcout << i << std::endl;
- stdcout << outpts[i] << " " << outpts[i+1] << std::endl;
+ stdcout << i << "\n";
+ stdcout << outpts[i] << " " << outpts[i+1] << "\n";
 return 0;
 }
 }
@@ -2183,10 +2183,10 @@
 stdcout << "fail merge 10\n";
 return false;
 }
- stdcout << (polys[0]) << std::endl;
+ stdcout << (polys[0]) << "\n";
 }
 for(unsigned int i = 0; i < 10; ++i) {
- stdcout << "random case # " << i << std::endl;
+ stdcout << "random case # " << i << "\n";
 si.clear();
 pts.clear();
 pts.push_back(Point(rand()%9-4, rand()%9-4));
@@ -2194,7 +2194,7 @@
 pts.push_back(Point(rand()%9-4, rand()%9-4));
 polygon_data<Unit> poly1;
 poly1.set(pts.begin(), pts.end());
- stdcout << poly1 << std::endl;
+ stdcout << poly1 << "\n";
 si.insert(poly1, 444);
 pts.clear();
 pts.push_back(Point(rand()%9-4, rand()%9-4));
@@ -2202,14 +2202,14 @@
 pts.push_back(Point(rand()%9-4, rand()%9-4));
 polygon_data<Unit> poly2;
 poly2.set(pts.begin(), pts.end());
- stdcout << poly2 << std::endl;
+ stdcout << poly2 << "\n";
 si.insert(poly2, 444);
 result.clear();
 si.merge(result);
- print(stdcout, si.pmd) << std::endl;
+ print(stdcout, si.pmd) << "\n";
 if(!result.empty()) {
 psd = (*(result.begin())).second;
- stdcout << psd << std::endl;
+ stdcout << psd << "\n";
 polys.clear();
 psd.get(polys);
 if(polys.size() == 0) {
@@ -2228,13 +2228,13 @@
 std::vector<polygon_data<Unit> > polys2;
 psd.get(polys2);
 if(!polys1.empty() || !polys2.empty()) {
- stdcout << "fail random merge " << i << std::endl;
+ stdcout << "fail random merge " << i << "\n";
 return false;
 }
 }
 }
 if(!polys.empty())
- stdcout << polys.size() << ": " << (polys[0]) << std::endl;
+ stdcout << polys.size() << ": " << (polys[0]) << "\n";
 }
 return true;
 }
@@ -2249,13 +2249,13 @@
 std::vector<polygon_data<Unit> > polys90;
 si.insert(rect1, 111);
 si90.insert(rect1, 111);
- stdcout << rect1 << std::endl;
+ stdcout << rect1 << "\n";
 si.insert(rect2, 222);
 si90.insert(rect2, 222);
- stdcout << rect2 << std::endl;
+ stdcout << rect2 << "\n";
 si.insert(rect3, 333);
 si90.insert(rect3, 333);
- stdcout << rect3 << std::endl;
+ stdcout << rect3 << "\n";
 si.merge(result);
 si90.merge(result90);
 if(result.size() != result90.size()) {
@@ -2277,20 +2277,20 @@
 psd90.get(polys90);
 if(polys.size() != polys90.size()) {
 stdcout << "merge failed with polygon count mismatch\n";
- stdcout << psd << std::endl;
+ stdcout << psd << "\n";
 for(std::size_t j = 0; j < polys.size(); ++j) {
- stdcout << polys[j] << std::endl;
+ stdcout << polys[j] << "\n";
 }
 stdcout << "reference\n";
 for(std::size_t j = 0; j < polys90.size(); ++j) {
- stdcout << polys90[j] << std::endl;
+ stdcout << polys90[j] << "\n";
 }
 return 0;
 }
 bool failed = false;
 for(std::size_t j = 0; j < polys.size(); ++j) {
- stdcout << polys[j] << std::endl;
- stdcout << polys90[j] << std::endl;
+ stdcout << polys[j] << "\n";
+ stdcout << polys90[j] << "\n";
#ifdef BOOST_POLYGON_ICC
#pragma warning (disable:1572)
#endif
@@ -2324,7 +2324,7 @@
 property_merge_90<property_type, Unit> si90;
 std::map<std::set<property_type>, polygon_90_set_data<Unit> > result90;
 std::vector<polygon_data<Unit> > polys90;
- stdcout << "random case # " << i << std::endl;
+ stdcout << "random case # " << i << "\n";
 set_points(rect1, (Point(rand()%9-4, rand()%9-4)), (Point(rand()%9-4, rand()%9-4)));
 set_points(rect2, (Point(rand()%9-4, rand()%9-4)), (Point(rand()%9-4, rand()%9-4)));
 set_points(rect3, (Point(rand()%9-4, rand()%9-4)), (Point(rand()%9-4, rand()%9-4)));
@@ -2356,7 +2356,7 @@
 si.insert(rect, 555);
 std::map<std::set<property_type>, polygon_set_data<Unit> > result;
 si.merge(result);
- print(stdcout, si.pmd) << std::endl;
+ print(stdcout, si.pmd) << "\n";
 for(typename std::map<std::set<property_type>, polygon_set_data<Unit> >::iterator itr = result.begin();
 itr != result.end(); ++itr) {
 stdcout << "( ";
@@ -2365,18 +2365,18 @@
 stdcout << (*set_itr) << " ";
 } stdcout << ") \n";
 polygon_set_data<Unit> psd = (*itr).second;
- stdcout << psd << std::endl;
+ stdcout << psd << "\n";
 std::vector<polygon_data<Unit> > polys;
 psd.get(polys);
 for(std::size_t i = 0; i < polys.size(); ++i) {
- stdcout << polys[i] << std::endl;
+ stdcout << polys[i] << "\n";
 }
 }
 std::vector<Point> pts;
 std::vector<polygon_data<Unit> > polys;
 for(unsigned int i = 0; i < 10; ++i) {
 property_merge si2;
- stdcout << "random case # " << i << std::endl;
+ stdcout << "random case # " << i << "\n";
 si.clear();
 pts.clear();
 pts.push_back(Point(rand()%9-4, rand()%9-4));
@@ -2384,7 +2384,7 @@
 pts.push_back(Point(rand()%9-4, rand()%9-4));
 polygon_data<Unit> poly1;
 poly1.set(pts.begin(), pts.end());
- stdcout << poly1 << std::endl;
+ stdcout << poly1 << "\n";
 si.insert(poly1, 444);
 si2.insert(poly1, 333);
 pts.clear();
@@ -2393,7 +2393,7 @@
 pts.push_back(Point(rand()%9-4, rand()%9-4));
 polygon_data<Unit> poly2;
 poly2.set(pts.begin(), pts.end());
- stdcout << poly2 << std::endl;
+ stdcout << poly2 << "\n";
 si.insert(poly2, 444);
 si2.insert(poly2, 444);
 pts.clear();
@@ -2402,7 +2402,7 @@
 pts.push_back(Point(rand()%9-4, rand()%9-4));
 polygon_data<Unit> poly3;
 poly3.set(pts.begin(), pts.end());
- stdcout << poly3 << std::endl;
+ stdcout << poly3 << "\n";
 si.insert(poly3, 444);
 si2.insert(poly3, 555);
 result.clear();
@@ -2418,15 +2418,15 @@
 stdcout << (*set_itr) << " ";
 } stdcout << ") \n";
 polygon_set_data<Unit> psd = (*itr).second;
- stdcout << psd << std::endl;
+ stdcout << psd << "\n";
 std::vector<polygon_data<Unit> > polys2;
 psd.get(polys2);
 for(std::size_t ii = 0; ii < polys2.size(); ++ii) {
- stdcout << polys2[ii] << std::endl;
+ stdcout << polys2[ii] << "\n";
 }
 }
 stdcout << "intersected pmd\n";
- print(stdcout, si2.pmd) << std::endl;
+ print(stdcout, si2.pmd) << "\n";
 stdcout << "intersected result\n";
 for(typename std::map<std::set<property_type>, polygon_set_data<Unit> >::iterator itr = result2.begin();
 itr != result2.end(); ++itr) {
@@ -2436,11 +2436,11 @@
 stdcout << (*set_itr) << " ";
 } stdcout << ") \n";
 polygon_set_data<Unit> psd = (*itr).second;
- stdcout << psd << std::endl;
+ stdcout << psd << "\n";
 std::vector<polygon_data<Unit> > polys2;
 psd.get(polys2);
 for(std::size_t ii = 0; ii < polys2.size(); ++ii) {
- stdcout << polys2[ii] << std::endl;
+ stdcout << polys2[ii] << "\n";
 }
 }
 si.clear();
@@ -2463,11 +2463,11 @@
 stdcout << (*set_itr) << " ";
 } stdcout << ") \n";
 polygon_set_data<Unit> psd = (*itr).second;
- stdcout << psd << std::endl;
+ stdcout << psd << "\n";
 std::vector<polygon_data<Unit> > polys2;
 psd.get(polys2);
 for(std::size_t ii = 0; ii < polys2.size(); ++ii) {
- stdcout << polys2[ii] << std::endl;
+ stdcout << polys2[ii] << "\n";
 }
 }
 std::vector<polygon_data<Unit> > polys2;
@@ -2475,7 +2475,7 @@
 (*(result.begin())).second.get(polys);
 (*(result2.begin())).second.get(polys2);
 if(!(polys == polys2)) {
- stdcout << "failed intersection check # " << i << std::endl;
+ stdcout << "failed intersection check # " <::BOOLEAN_OR);
 psd3.get(pv);
 for(std::size_t i = 0; i < pv.size(); ++i) {
- stdcout << pv[i] << std::endl;
+ stdcout << pv[i] << "\n";
 }
 pv.clear();
 abo.clear();
@@ -2668,7 +2668,7 @@
 abo.execute(psd3, psd.begin(), psd.end(), psd2.begin(), psd2.end(), arbitrary_boolean_op<Unit>::BOOLEAN_AND);
 psd3.get(pv);
 for(std::size_t i = 0; i < pv.size(); ++i) {
- stdcout << pv[i] << std::endl;
+ stdcout << pv[i] << "\n";
 }
 pv.clear();
 abo.clear();
@@ -2676,7 +2676,7 @@
 abo.execute(psd3, psd.begin(), psd.end(), psd2.begin(), psd2.end(), arbitrary_boolean_op<Unit>::BOOLEAN_XOR);
 psd3.get(pv);
 for(std::size_t i = 0; i < pv.size(); ++i) {
- stdcout << pv[i] << std::endl;
+ stdcout << pv[i] << "\n";
 }
 pv.clear();
 abo.clear();
@@ -2684,7 +2684,7 @@
 abo.execute(psd3, psd.begin(), psd.end(), psd2.begin(), psd2.end(), arbitrary_boolean_op<Unit>::BOOLEAN_NOT);
 psd3.get(pv);
 for(std::size_t i = 0; i < pv.size(); ++i) {
- stdcout << pv[i] << std::endl;
+ stdcout << pv[i] << "\n";
 }
 return true;
 }

Next message: lucanus.j.simonson_at_[hidden]: "[Boost-commit] svn:boost r80596 - trunk/boost/polygon/detail"
Previous message: vicente.botet_at_[hidden]: "[Boost-commit] svn:boost r80594 - in trunk/boost/thread: . detail"

Date view	Thread view	Subject view	Author view

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