factory Namespace Reference

Contains predefined ways to initialize a graph. More...

Functions

template<typename Graph , class Model >
bool hex_grid (size_t N, size_t M, Graph &G, Model &model, bool torus=false)
 Build a hexagonal grid with N lines and M columns.
template<typename Graph , class Model >
bool square_grid (size_t N, size_t M, Graph &G, Model &model, bool torus=false, bool connect8=false)
 Create a square grid with N lines and M columns.

Detailed Description

Contains predefined ways to initialize a graph.


Function Documentation

template<typename Graph , class Model >
bool factory::hex_grid ( size_t  N,
size_t  M,
Graph &  G,
Model model,
bool  torus = false 
) [inline]

Build a hexagonal grid with N lines and M columns.

Parameters:
N Number of lines of the grid
M Number of columns of the grid
G Graph to fill in
model Model containing initialisation method
torus True to connect the top cells to the bottom ones and the left cells to the right ones. Requires an even number of lines.
Returns:
True if successful

Definition at line 257 of file grid.h.

Referenced by complex_factory::hex_grid().

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   }

template<typename Graph , class Model >
bool factory::square_grid ( size_t  N,
size_t  M,
Graph &  G,
Model model,
bool  torus = false,
bool  connect8 = false 
) [inline]

Create a square grid with N lines and M columns.

Parameters:
N Number of lines
M Number of columns
G Graph to initialize as a grid
m Model containing the initialization functions
torus Connect the top cells to the bottom ones and the left cells to the right ones if true.
connect8 Set to true to get a 8-connected grid, false to get a 4-connected grid.
Returns:
True if successful

The model should contain this method:

  void initGridVertex(size_t i, size_t j, const vertex&, Graph&)

Initialize a newly created vertex at line i and column j

The neighbors are oriented in that order: bottom -> right -> top -> left

With the bottom-left corner being the one of coordinate (0,0).

The graph is cleared at the beginning of the process

Definition at line 46 of file grid.h.

Referenced by complex_factory::square_grid().

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   }

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Generated on Fri May 31 15:38:07 2013 for VVE by  doxygen 1.6.3