grid.h

Go to the documentation of this file.
00001 #ifndef VVELIB_FACTORY_GRID_H
00002 #define VVELIB_FACTORY_GRID_H
00003 
00009 #include <config.h>
00010 #include <list>
00011 
00015 namespace factory
00016 {
00045   template <typename Graph, class Model>
00046   bool square_grid(size_t N, size_t M, Graph& G, Model& model, bool torus = false, bool connect8 = false)
00047   {
00048     typedef typename Graph::vertex_t vertex;
00049     typedef typename Graph::edge_t edge;
00050     // First, clear the graph
00051     G.clear();
00052     // Array of vertices by position
00053     std::vector<vertex> vertices(M*N, vertex(0));
00054     // Create the vertices and insert them
00055     for(size_t k = 0 ; k < M*N ; ++k)
00056     {
00057       vertex v;
00058       G.insert(v);
00059       vertices[k] = v;
00060     }
00061     // Create the edges
00062     size_t k = 0;
00063     const size_t delta_border_i = M*(N-1);
00064     const size_t delta_border_j = M-1;
00065     const size_t delta_i = M;
00066     const size_t delta_j = 1;
00067     for(size_t i = 0 ; i < N ; ++i)
00068       for(size_t j = 0 ; j < M ; ++j, ++k)
00069       {
00070         vertex v = vertices[k];
00071         // Connect to the right
00072         if(j == M-1)
00073         {
00074           if(torus)
00075             G.insertEdge(v, vertices[k-delta_border_j]);
00076         }
00077         else
00078           G.insertEdge(v, vertices[k+delta_j]);
00079         // Connect to the top
00080         if(i == N-1)
00081         {
00082           if(torus)
00083             G.insertEdge(v, vertices[k-delta_border_i]);
00084         }
00085         else
00086           G.insertEdge(v, vertices[k+delta_i]);
00087         // Connect to the left
00088         if(j == 0)
00089         {
00090           if(torus)
00091           {
00092             if(i==N-1)
00093               G.spliceAfter(v, vertices[k-delta_border_i], vertices[k+delta_border_j]);
00094             else
00095               G.spliceAfter(v, vertices[k+delta_i], vertices[k+delta_border_j]);
00096           }
00097         }
00098         else
00099         {
00100           if(i==N-1)
00101           {
00102             if(j == M-1)
00103               G.insertEdge(v, vertices[k-delta_j]);
00104             else
00105               G.spliceAfter(v, vertices[k+delta_j], vertices[k-delta_j]);
00106           }
00107           else
00108             G.spliceAfter(v, vertices[k+delta_i], vertices[k-delta_j]);
00109         }
00110         // Connect to the bottom
00111         if(i == 0)
00112         {
00113           if(torus)
00114           {
00115             if(j==0)
00116               G.spliceAfter(v, vertices[k+delta_border_j], vertices[k+delta_border_i]);
00117             else
00118               G.spliceAfter(v, vertices[k-delta_j], vertices[k+delta_border_i]);
00119           }
00120         }
00121         else
00122         {
00123           if(j==0)
00124             G.spliceBefore(v, vertices[k+delta_j], vertices[k-delta_i]);
00125           else
00126             G.spliceAfter(v, vertices[k-delta_j], vertices[k-delta_i]);
00127         }
00128       }
00129     if(connect8)
00130     {
00131       const size_t delta_ij = M+1;
00132       const size_t delta_mij = M-1;
00133       const size_t bottom_left_corner = 0;
00134       const size_t bottom_right_corner = M-1;
00135       const size_t top_left_corner = M*(N-1);
00136       const size_t top_right_corner = M*N-1;
00137       const size_t delta_border_bottom_ij = M*(N-1)-1;
00138       const size_t delta_border_right_ij = 1;
00139       const size_t delta_border_bottom_mij = M*(N-1)+1;
00140       const size_t delta_border_left_mij = 2*M-1;
00141       k = 0;
00142       for(size_t i = 0 ; i < N ; ++i)
00143         for(size_t j = 0 ; j < M ; ++j, ++k)
00144         {
00145           vertex v = vertices[k];
00146           // ** Connect to the bottom-left
00147           if(i == 0 && j == 0)
00148           {
00149             // If in the corner
00150             if(torus)
00151               G.spliceAfter(v, vertices[bottom_right_corner], vertices[top_right_corner]);
00152           }
00153           else if(i == 0)
00154           {
00155             // If on the bottom line
00156             if(torus)
00157               G.spliceAfter(v, vertices[k-delta_j], vertices[k+delta_border_bottom_ij]);
00158           }
00159           else if(j == 0)
00160           {
00161             // If on the left border
00162             if(torus)
00163               G.spliceBefore(v, vertices[k-delta_i], vertices[k-delta_border_right_ij]);
00164           }
00165           else
00166             G.spliceAfter(v, vertices[k-delta_j], vertices[k-delta_ij]);
00167 
00168           // ** Connect the bottom-right
00169           if(i == 0 && j == M-1)
00170           {
00171             // If in the corner
00172             if(torus)
00173               G.spliceAfter(v, vertices[top_right_corner], vertices[top_left_corner]);
00174           }
00175           else if(i == 0)
00176           {
00177             // If on the bottom line
00178             if(torus)
00179               G.spliceBefore(v, vertices[k+delta_j], vertices[k+delta_border_bottom_mij]);
00180           }
00181           else if(j == M-1)
00182           {
00183             // If on the right line
00184             if(torus)
00185               G.spliceAfter(v, vertices[k-delta_i], vertices[k-delta_border_left_mij]);
00186           }
00187           else
00188             G.spliceAfter(v, vertices[k-delta_i], vertices[k-delta_mij]);
00189 
00190           // ** Connect to the top-right
00191           if(i == N-1 && j == M-1)
00192           {
00193             // If on the corner
00194             if(torus)
00195               G.spliceAfter(v, vertices[top_left_corner], vertices[bottom_left_corner]);
00196           }
00197           else if(i == N-1)
00198           {
00199             // If on the top line
00200             if(torus)
00201               G.spliceAfter(v, vertices[k+delta_j], vertices[k-delta_border_bottom_ij]);
00202           }
00203           else if(j == M-1)
00204           {
00205             // If on the right line
00206             if(torus)
00207               G.spliceBefore(v, vertices[k+delta_i], vertices[k+delta_border_right_ij]);
00208           }
00209           else
00210             G.spliceAfter(v, vertices[k+delta_j], vertices[k+delta_ij]);
00211 
00212           // ** Connect to the top-left
00213           if(i == N-1 && j == 0)
00214           {
00215             // If on the bottom-left corner
00216             if(torus)
00217               G.spliceAfter(v, vertices[bottom_left_corner], vertices[bottom_right_corner]);
00218           }
00219           else if(i == N-1)
00220           {
00221             // If on the top line
00222             if(torus)
00223               G.spliceBefore(v, vertices[k-delta_j], vertices[k-delta_border_bottom_mij]);
00224           }
00225           else if(j == 0)
00226           {
00227             // If on the left line
00228             if(torus)
00229               G.spliceAfter(v, vertices[k+delta_i], vertices[k+delta_border_left_mij]);
00230           }
00231           else
00232             G.spliceBefore(v, vertices[k-delta_j], vertices[k+delta_mij]);
00233         }
00234     }
00235     k = 0;
00236     for(size_t i = 0 ; i < N ; ++i)
00237       for(size_t j = 0 ; j < M ; ++j, ++k)
00238       {
00239         model.initGridVertex(i, j, vertices[k], G);
00240       }
00241     return true;
00242   }
00243 
00256   template <typename Graph, class Model>
00257   bool hex_grid(size_t N, size_t M, Graph& G, Model& model, bool torus = false)
00258   {
00259     if(torus and N%2)
00260       return false;
00261     typedef typename Graph::vertex_t vertex;
00262     typedef typename Graph::edge_t edge;
00263     // First, clear the graph
00264     G.clear();
00265     // Array of vertices by position
00266     std::vector<vertex> vertices(M*N, vertex(0));
00267     // Create the vertices and insert them
00268     for(size_t k = 0 ; k < M*N ; ++k)
00269     {
00270       vertex v;
00271       G.insert(v);
00272       vertices[k] = v;
00273     }
00274     // Create the edges
00275     size_t k = 0;
00276     const size_t delta_right = 1;
00277     const size_t delta_top_right_even = M;
00278     const size_t delta_top_right_odd = M+1;
00279     const size_t delta_top_left_even = M-1;
00280     const size_t delta_top_left_odd = M;
00281     const size_t delta_bottom_border_bottom_right = M*(N-1);
00282     const size_t delta_bottom_border_bottom_left = M*(N-1)-1;
00283     const size_t delta_right_border_top_right = 1;
00284     const size_t delta_left_border_left = M-1;
00285     const size_t delta_left_border_top_left = 2*M-1;
00286     const size_t top_right_corner = M*N-1;
00287     const size_t bottom_left_corner = 0;
00288     for(size_t i = 0 ; i < N ; ++i)
00289       for(size_t j = 0 ; j < M ; ++j, ++k)
00290       {
00291         vertex v = vertices[k];
00292         // ** Connect to the right
00293         if(j == M-1)
00294         {
00295           if(torus)
00296             G.insertEdge(v, vertices[k-delta_left_border_left]);
00297         }
00298         else
00299           G.insertEdge(v, vertices[k+delta_right]);
00300         // ** Connect to the left
00301         if(j==0)
00302         {
00303           if(torus)
00304             G.insertEdge(v, vertices[k+delta_left_border_left]);
00305         }
00306         else
00307           G.insertEdge(v, vertices[k-delta_right]);
00308         // ** Connect to the top-right
00309         if(k == top_right_corner)
00310         {
00311           if(torus)
00312             G.spliceAfter(v, vertices[k-delta_left_border_left], vertices[bottom_left_corner]);
00313         }
00314         else if(i == N-1)
00315         {
00316           if(torus)
00317             G.spliceAfter(v, vertices[k+delta_right], vertices[k-delta_bottom_border_bottom_left]);
00318         }
00319         else if(i%2)
00320         {
00321           if(j == M-1)
00322           {
00323             if(torus)
00324               G.spliceAfter(v, vertices[k-delta_left_border_left], vertices[k+delta_right_border_top_right]);
00325           }
00326           else
00327             G.spliceAfter(v, vertices[k+delta_right], vertices[k+delta_top_right_odd]);
00328         }
00329         else if(j == M-1)
00330           G.spliceBefore(v, vertices[k-delta_right], vertices[k+delta_top_right_even]);
00331         else
00332           G.spliceAfter(v, vertices[k+delta_right], vertices[k+delta_top_right_even]);
00333         // ** Connect to the top-left
00334         if(k == top_right_corner)
00335         {
00336           if(torus)
00337             G.spliceAfter(v, vertices[bottom_left_corner], vertices[k-delta_bottom_border_bottom_right]);
00338         }
00339         else if(i == N-1)
00340         {
00341           if(torus)
00342             G.spliceBefore(v, vertices[k-delta_right], vertices[k-delta_bottom_border_bottom_right]);
00343         }
00344         else if(i%2)
00345         {
00346           if(j == 0)
00347             G.spliceAfter(v, vertices[k+delta_top_right_odd], vertices[k+delta_top_left_odd]);
00348           else
00349             G.spliceBefore(v, vertices[k-delta_right], vertices[k+delta_top_left_odd]);
00350         }
00351         else
00352         {
00353           if(j == 0)
00354           {
00355             if(torus)
00356               G.spliceAfter(v, vertices[k+delta_top_right_even], vertices[k+delta_left_border_top_left]);
00357           }
00358           else
00359             G.spliceBefore(v, vertices[k-delta_right], vertices[k+delta_top_left_even]);
00360         }
00361         // ** Connect to the bottom-left
00362         if(k == bottom_left_corner)
00363         {
00364           if(torus)
00365             G.spliceBefore(v, vertices[k+delta_right], vertices[top_right_corner]);
00366         }
00367         else if(i == 0)
00368         {
00369           if(torus)
00370             G.spliceAfter(v, vertices[k-delta_right], vertices[k+delta_bottom_border_bottom_left]);
00371         }
00372         else if(i%2)
00373         {
00374           if(j==0)
00375             G.spliceBefore(v, vertices[k+delta_right], vertices[k-delta_top_right_even]);
00376           else
00377             G.spliceAfter(v, vertices[k-delta_right], vertices[k-delta_top_right_even]);
00378         }
00379         else if(j == 0)
00380         {
00381           if(torus)
00382             G.spliceBefore(v, vertices[k+delta_right], vertices[k-delta_right_border_top_right]);
00383         }
00384         else
00385           G.spliceAfter(v, vertices[k-delta_right], vertices[k-delta_top_right_odd]);
00386         // ** Connect to the bottom-right
00387         if(k == bottom_left_corner)
00388         {
00389           if(torus)
00390             G.spliceAfter(v, vertices[top_right_corner], vertices[k+delta_bottom_border_bottom_right]);
00391         }
00392         else if(i == 0)
00393         {
00394           if(torus)
00395             G.spliceAfter(v, vertices[k+delta_bottom_border_bottom_left], vertices[k+delta_bottom_border_bottom_right]);
00396         }
00397         else if(i%2)
00398         {
00399           if(j==M-1)
00400           {
00401             if(torus)
00402               G.spliceBefore(v, vertices[k-delta_left_border_left], vertices[k-delta_left_border_top_left]);
00403           }
00404           else
00405             G.spliceBefore(v, vertices[k+delta_right], vertices[k-delta_top_left_even]);
00406         }
00407         else if(j == M-1)
00408           G.spliceAfter(v, vertices[k-delta_top_right_odd], vertices[k-delta_top_left_odd]);
00409         else
00410           G.spliceBefore(v, vertices[k+delta_right], vertices[k-delta_top_left_odd]);
00411       }
00412     k = 0;
00413     for(size_t i = 0 ; i < N ; ++i)
00414       for(size_t j = 0 ; j < M ; ++j, ++k)
00415       {
00416         model.initGridVertex(i, j, vertices[k], G);
00417       }
00418     return true;
00419   }
00420 }
00421 
00422 #endif // VVELIB_FACTORY_GRID_H
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Generated on Fri May 31 15:37:50 2013 for VVE by  doxygen 1.6.3