more quadtrees test + some minor bugs correction

Author: arodrigue003

CMakeLists.txt

@@ -6,7 +6,7 @@ set(BOOST_REQUIRED_VERSION 1.62.0)
 set(EXE_NAME "packer")
 
 # Compiler flags
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wfatal-errors -std=c++11 -fopenmp")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wfatal-errors -std=c++11 -O0 -g -fopenmp")
 
 # Options
 option(FORCE_UNPACK "Boost unpack forcing" 0) #Set to 1 to force local installation of Boost (ensure that it will take priority)

src/Shape.cpp

@@ -245,7 +245,6 @@ Point Shape::centroid() const {
  * @param s Another shape
  */
 bool Shape::intersectsWith(const Shape& s) const {
-	cerr << "Shape called" << endl;
     return bg::overlaps(_multiP, s._multiP);
 }
 

src/Shape.hpp

@@ -73,7 +73,7 @@ class Shape {
     virtual void translate(double Tx, double Ty);
     virtual void envelope(Box&) const;
     virtual Point centroid() const;
-    virtual int area() const;
+	virtual int area() const;
     virtual bool intersectsWith(const Shape&) const;
     virtual bool intersectsWith(const Ring& s) const;
     virtual void convexHull(Polygon&) const;

src/quadtree/InnerQuadTree.cpp

@@ -1,5 +1,6 @@
 #include <iostream>
 #include <cmath>
+#include <iomanip>
 
 #include <boost/geometry.hpp>
 // Plante sans cette include pour une raison indeterminé
@@ -151,8 +152,7 @@ bool InnerQuadTree::intersectsRec(const InnerQuadTree& q, float offsetX1, float
     	return false;
     */
     Box b1{{x1 + offsetX1, y1 + offsetY1}, {x2 + offsetX1, y2 + offsetY1}};
-    Box b2{{q.x1 + offsetX2, q.y1 + offsetY2}, {q.x2 + offsetX2, q.y2 + offsetY2}};
-	cout << bg::wkt(b1) << ":" << bg::wkt(b2) << endl;
+	Box b2{{q.x1 + offsetX2, q.y1 + offsetY2}, {q.x2 + offsetX2, q.y2 + offsetY2}};
     bool boxIntersects = bg::intersects(b1, b2);
     //cout << boxIntersects << test << endl;
 
@@ -265,8 +265,9 @@ void InnerQuadTree::translater(float x, float y) {
 
 
 std::ostream& operator<<(std::ostream& s, const InnerQuadTree& q) {
-	s << "Boundind box : (" << q.x1 << "," << q.y1 << ")-(" << q.x2 << "," << q.y2 << ")    " <<
-		 "Size : " << q.x2 - q.x1 << "," << q.y2 - q.y1 << "    InnerTrees : " << q.size;
+	s << fixed << setprecision(2);
+	s << setw(6) << "Boundind box : (" << setw(6) << q.x1 << "," << setw(6) << q.y1 << ")-(" << setw(6) << q.x2 << "," << setw(6) << q.y2 << ")    " <<
+		 "Size : (" << setw(8) << (q.x2 - q.x1) << "," << setw(8) << (q.y2 - q.y1) << ")    InnerTrees : " << q.size;
     return s;
 }
 

src/quadtree/QuadTree.cpp

@@ -4,6 +4,8 @@
 #include <fstream>
 
 
+#include <boost/geometry/algorithms/area.hpp>
+#include <boost/geometry/strategies/cartesian/area_surveyor.hpp>
 #include <boost/geometry/algorithms/correct.hpp>
 #include <boost/geometry/algorithms/intersects.hpp>
 #include <boost/math/constants/constants.hpp>
@@ -33,7 +35,8 @@ void QuadTree::copy(const QuadTree& q) {
     _totalX = q._totalX;
     _totalY = q._totalY;
     _maxDepth = q._maxDepth;
-    precision = q.precision;
+	precision = q.precision;
+	_area = q._area;
 }
 
 /**
@@ -70,7 +73,8 @@ QuadTree& QuadTree::operator=(QuadTree&& q) {
         _totalX = q._totalX;
         _totalY = q._totalY;
         _maxDepth = q._maxDepth;
-        precision = q.precision;
+		precision = q.precision;
+		_area = q._area;
     }
 
     return *this;
@@ -113,7 +117,8 @@ QuadTree::QuadTree(Shape& s, float precision) :
    than precision can be detected by the quadtree
  */
 QuadTree::QuadTree(MultiPolygon& mult, float precision, unsigned id)
-    : Shape(mult, id), trees(nullptr), precision(precision) {
+	: Shape(mult, id), trees(nullptr), precision(precision) {
+	_area =  bg::area(mult);
     float rotationAngle = 360.f / quadsNumber;
     float currentAngle = 0.f;
     trees = new InnerQuadTree*[quadsNumber];
@@ -175,55 +180,52 @@ QuadTree::QuadTree(MultiPolygon& mult, float precision, unsigned id)
  * @param q
  * @return
  */
-bool QuadTree::intersectsWith(const QuadTree& q) const {
-	cerr << "QuadTree instersect called" << endl;
+bool QuadTree::intersectsWith(const Shape& s) const {
+	const QuadTree& q = static_cast<const QuadTree &>(s);
     return trees[currentTree]->intersectsRec(*q.trees[q.currentTree], _totalX, _totalY,
             q._totalX, q._totalY);
 }
 
 /**
- * @brief QuadTree::translater translates the QuadTree position
- * @param x
- * @param y
- */
-void QuadTree::translater(float x, float y) {
-    _totalX += x;
-    _totalY += y;
-}
-
-/**
- * @brief QuadTree::rotater rotate a QuadTree
+ * @brief QuadTree::rotate overload of Shape::rotate for quadtrees
+ * rotate a QuadTree
  * The rotation is around the (0,0) point by default
  * Better rotation is possible with the possibility to choose the rotation point
  * @param angle rotation angle in degree, stored in radians
  */
-void QuadTree::rotater(float angle) {
-    unsigned newQuad = (int) round(angle * quadsNumber / 360) % quadsNumber;
-    float newAngle = pi * angle / 180.f;
-    // Compute the tree position
-    float newX = cos(newAngle) * _totalX - sin(newAngle) * _totalY;
-    float newY = sin(newAngle) * _totalX + cos(newAngle) * _totalY;
-    newX += treesOffset[newQuad].x();
-    newY += treesOffset[newQuad].y();
-    currentTree = newQuad;
-}
-
-/**
- * @brief QuadTree::rotate overload of Shape::rotate for quadtrees
- * @param x
- * @param y
- */
-void QuadTree::rotate(double angle) {
-    rotater(angle);
+void QuadTree::rotate(double degrees) {
+	float anglePrecision = 360.0 / quadsNumber;
+	float angle = static_cast<float>(degrees) + anglePrecision*currentTree;
+	_totalX -= treesOffset[currentTree].x();
+	_totalY -= treesOffset[currentTree].y();
+
+	unsigned newQuad = (int) round(angle / anglePrecision) % quadsNumber;
+	float newAngle = pi * angle / 180.f;
+	// Compute the tree position
+	float newX = cos(newAngle) * _totalX - sin(newAngle) * _totalY;
+	float newY = sin(newAngle) * _totalX + cos(newAngle) * _totalY;
+	_totalX = newX + treesOffset[newQuad].x();
+	_totalY = newY + treesOffset[newQuad].y();
+	currentTree = newQuad;
 }
 
 /**
  * @brief QuadTree::translate overload of Shape::translate for quadtrees
+ * translates the QuadTree position
  * @param x
  * @param y
  */
 void QuadTree::translate(double Tx, double Ty) {
-    translater(Tx, Ty);
+	_totalX += static_cast<float>(Tx);
+	_totalY += static_cast<float>(Ty);
+}
+
+void QuadTree::envelope(Box& b) const {
+	b = {{_totalX,_totalY},{_totalX+trees[currentTree]->x2,_totalY+trees[currentTree]->y2}};
+}
+
+int QuadTree::area() const {
+	return _area;
 }
 
 /**
@@ -234,6 +236,7 @@ void QuadTree::translate(double Tx, double Ty) {
 std::ostream& operator <<(std::ostream& s, const QuadTree& q) {
 	s << "QuadTree n° : " << q.getIdentifier() << endl;
     s << "Absolute Position : (" << q._totalX << "," << q._totalY << ") " << endl;
+	s << "Current tree (angle) : " << q.currentTree << "(" << 30*q.currentTree << ")" << endl;
 
 	s << "Trees : " << std::endl;
     for (unsigned i = 0; i < q.quadsNumber; i++)

src/quadtree/QuadTree.hpp

@@ -20,8 +20,8 @@ class QuadTree : public Shape {
 
     float _totalX, _totalY;
     int _maxDepth;
-    float precision;
-
+	float precision;
+	int _area;
 
 private:
     void copy(const QuadTree&);
@@ -33,17 +33,16 @@ class QuadTree : public Shape {
     ~QuadTree();
 
 public:
-    QuadTree(Shape&, float precision);
-    QuadTree(MultiPolygon& mult, float precision, unsigned id);
-
-public:
-    void translater(float x, float y);
-    void rotater(float angle);
+	QuadTree(Shape&, float precision);
+	QuadTree(MultiPolygon& mult, float precision, unsigned id);
 
 public:
+	// Overrided algorithms
     void rotate(double degrees) override;
     void translate(double Tx, double Ty) override;
-    bool intersectsWith(const QuadTree&) const;
+	bool intersectsWith(const Shape&) const override;
+	void envelope(Box&) const override;
+	int area() const override;
 
 private:
     void saveTree(std::string filename, int depth);

test/quadtreeTest.cpp

@@ -25,6 +25,8 @@ using Clock = std::chrono::system_clock;
 using namespace std;
 
 int main() {
+	static bool verboseDebug = false;
+
 	srand(time(0));
 
 	//Will contain the IDs the solver will pack
@@ -40,14 +42,15 @@ int main() {
 	int celapsed = chrono::duration_cast<chrono::microseconds>(cend - cstart).count();
 	cerr << "Parsing and quadtree creation time : " << celapsed << " microseconds elapsed" << endl;
 
-
-	for(size_t i=0; i<shapes.size(); i++) {
-		QuadTree& quad = dynamic_cast<QuadTree&>(shapes[i]);
-		cout << quad << endl;
+	if (verboseDebug) {
+		for(size_t i=0; i<shapes.size(); i++) {
+			QuadTree& quad = dynamic_cast<QuadTree&>(shapes[i]);
+			cout << quad << endl;
+		}
 	}
 
 	// Intersection accuracy verification
-	cerr << "Testting intersection accuracy :" << endl;
+	cerr << "Testing intersection accuracy" << endl;
 	bool noerr=true;
 	for(size_t i=0; i<shapes.size(); i++) {
 		for(size_t j=i+1; j<shapes.size(); j++) {
@@ -62,6 +65,65 @@ int main() {
 	else
 		cerr << "Some errors where find, see upside for more details" << endl;
 
+
+	//Translation tests
+	cerr << "Testing Translation accuracy" << endl;
+	shapes[3].translate(-50, -150);
+	ASSERT( shapes[0].intersectsWith(shapes[3]), "First Translation error 1");
+	ASSERT( shapes[1].intersectsWith(shapes[3]), "First Translation error 2");
+	ASSERT(!shapes[2].intersectsWith(shapes[3]), "First Translation error 3");
+	ASSERT( shapes[4].intersectsWith(shapes[3]), "First Translation error 4");
+	ASSERT( shapes[5].intersectsWith(shapes[3]), "First Translation error 5");
+
+	shapes[2].translate(50,-150);
+	ASSERT(shapes[0].intersectsWith(shapes[2]), "Second Translation error 1");
+	ASSERT(shapes[1].intersectsWith(shapes[2]), "Second Translation error 2");
+	ASSERT(shapes[3].intersectsWith(shapes[2]), "Second Translation error 3");
+	ASSERT(shapes[4].intersectsWith(shapes[2]), "Second Translation error 4");
+	ASSERT(shapes[5].intersectsWith(shapes[2]), "Second Translation error 5");
+	cerr << "No error found" << endl;
+
+	// Rotation test
+	cerr << "Testing Rotation accuracy" << endl;
+	Box test;
+	shapes[0].rotate(90);
+	shapes[0].envelope(test);
+	ASSERT(abs(test.min_corner().x() - 0)     < pow(10,-4), "Rotation 1-1");
+	ASSERT(abs(test.min_corner().y() - -99.5) < pow(10,-4), "Rotation 1-2");
+	ASSERT(abs(test.max_corner().x() - 99.5)  < pow(10,-4), "Rotation 1-3");
+	ASSERT(abs(test.max_corner().y() - 0)     < pow(10,-4), "Rotation 1-4");
+	if (verboseDebug)
+		cout << dynamic_cast<QuadTree&>(shapes[0]) << endl;
+
+	shapes[0].rotate(90);
+	shapes[0].envelope(test);
+	ASSERT(abs(test.min_corner().x() - -99.5) < pow(10,-4), "Rotation 2-1");
+	ASSERT(abs(test.min_corner().y() - -99.5) < pow(10,-4), "Rotation 2-2");
+	ASSERT(abs(test.max_corner().x() - 0)     < pow(10,-4), "Rotation 2-3");
+	ASSERT(abs(test.max_corner().y() - 0)     < pow(10,-4), "Rotation 2-4");
+	if (verboseDebug)
+		cout << dynamic_cast<QuadTree&>(shapes[0]) << endl;
+
+	shapes[0].rotate(90);
+	shapes[0].envelope(test);
+	ASSERT(abs(test.min_corner().x() - -99.5) < pow(10,-4), "Rotation 3-1");
+	ASSERT(abs(test.min_corner().y() - 0)     < pow(10,-4), "Rotation 3-2");
+	ASSERT(abs(test.max_corner().x() - 0)     < pow(10,-4), "Rotation 3-3");
+	ASSERT(abs(test.max_corner().y() - 99.5)  < pow(10,-4), "Rotation 3-4");
+	if (verboseDebug)
+		cout << dynamic_cast<QuadTree&>(shapes[0]) << endl;
+
+	shapes[0].rotate(90);
+	shapes[0].envelope(test);
+	ASSERT(abs(test.min_corner().x() - 0)     < pow(10,-4), "Rotation 4-1");
+	ASSERT(abs(test.min_corner().y() - 0)     < pow(10,-4), "Rotation 4-2");
+	ASSERT(abs(test.max_corner().x() - 99.5)  < pow(10,-4), "Rotation 4-3");
+	ASSERT(abs(test.max_corner().y() - 99.5)  < pow(10,-4), "Rotation 4-4");
+	if (verboseDebug)
+		cout << dynamic_cast<QuadTree&>(shapes[0]) << endl;
+	cerr << "No error found" << endl;
+
+
 	/*bitmap bmap(shapes[1].getMultiP(), 99, 100);
 	bmap.saveMap("test");
 	for (size_t i=0; i<quads.size(); i++)