Additions and modifications

- Correct name/order of child quadtrees (SO and NE invert)
- Add concatenation of 4 surfaces into one

src/quadtree.cpp

@@ -19,8 +19,8 @@ QuadTree::QuadTree(SDL_Surface * image, short niveau_p): niveau(niveau_p), coule
 
         final = false;
         nord_ouest = new QuadTree(image_coupe.at(0), niveau + 1);
-        nord_est   = new QuadTree(image_coupe.at(1), niveau + 1);
+        sud_ouest  = new QuadTree(image_coupe.at(1), niveau + 1);
-        sud_ouest  = new QuadTree(image_coupe.at(2), niveau + 1);
+        nord_est   = new QuadTree(image_coupe.at(2), niveau + 1);
         sud_est    = new QuadTree(image_coupe.at(3), niveau + 1);
 
         for(SDL_Surface * it: image_coupe) {
@@ -104,3 +104,62 @@ std::array<SDL_Surface *, 4> QuadTree::coupeEnQuatre(SDL_Surface * s) {
 
     return resultat;
 }
+
+SDL_Surface * QuadTree::colleQuatreImages(std::array<SDL_Surface *, 4> morceaux) {
+    // Récupère la hauteur/largeur de l'image qui est composé des 4 sous-images
+    // Double les dimensions des morceaux en diagonale (ici NO et SE)
+    int largeur = (morceaux[0]->w * 2 == morceaux[3]->w * 2) ? morceaux[0]->w * 2 : -1;
+    int hauteur = (morceaux[0]->h * 2 == morceaux[3]->h * 2) ? morceaux[0]->w * 2 : -1;
+
+    // Si dimensions différente alors on prend l'entre-deux
+    if(largeur == -1) {
+        if(morceaux[0]->w * 2 > morceaux[3]->w * 2) {
+            largeur = morceaux[0]->w * 2 - 1;
+        } else {
+            largeur = morceaux[3]->w * 2 - 1;
+        }
+    }
+    if(hauteur == -1) {
+        if(morceaux[0]->h * 2 > morceaux[3]->h * 2) {
+            hauteur = morceaux[0]->h * 2 - 1;
+        } else {
+            hauteur = morceaux[3]->h * 2 - 1;
+        }
+    }
+
+    SDL_Surface * nouvelle_image = SDL_CreateRGBSurface(0, largeur, hauteur, 32, r_mask, g_mask, b_mask, a_mask);
+
+    // Copie chacun son tour les morceaux d'image dans l'image
+    if(SDL_LockSurface(nouvelle_image) == 0) {
+        for(Uint32 i = 0; i < morceaux.size(); ++i) {
+            int decalage_x = 0, decalage_y = 0; // NO
+            switch(i) {
+                case 1: // SO
+                    decalage_y = morceaux[0]->h; // décalé sur Y en fonction de NO
+                    break;
+                case 2: // NE
+                    decalage_x = morceaux[0]->w; // décalé sur X en fonction de NO
+                    break;
+                case 3: // SE
+                    decalage_x = morceaux[1]->w; // décalé sur X en fonction de SO (== NO)
+                    decalage_y = morceaux[2]->h; // décalé sur Y en fonction de NE
+                    break;
+                default:
+                    break;
+            }
+            for(int x = 0; x < morceaux[i]->w; ++x) {
+                for(int y = 0; y < morceaux[i]->h; ++y) {
+                    *reinterpret_cast<Uint32 *>(
+                        static_cast<Uint8 *>(nouvelle_image->pixels) + (y + decalage_y) * nouvelle_image->pitch + (x + decalage_x) * nouvelle_image->format->BytesPerPixel
+                    ) = *reinterpret_cast<Uint32 *>(
+                        static_cast<Uint8 *>(morceaux[i]->pixels) + y * morceaux[i]->pitch + x * morceaux[i]->format->BytesPerPixel
+                    );
+                }
+            }
+        }
+
+        SDL_UnlockSurface(nouvelle_image);
+    }
+
+    return nouvelle_image;
+}